Managed Service for Apache Kafka API v1 API - Class ManagedKafkaConnectClient (1.0.0-beta05)

Stay organized with collections Save and categorize content based on your preferences.

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ConnectCluster connectCluster = new ConnectCluster();
string connectClusterId = "";
// Make the request
Operation<ConnectCluster, OperationMetadata> response = managedKafkaConnectClient.CreateConnectCluster(parent, connectCluster, connectClusterId);

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

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
CreateConnectClusterRequest request = new CreateConnectClusterRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ConnectClusterId = "",
    ConnectCluster = new ConnectCluster(),
    RequestId = "",
};
// Make the request
Operation<ConnectCluster, OperationMetadata> response = managedKafkaConnectClient.CreateConnectCluster(request);

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

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ConnectCluster connectCluster = new ConnectCluster();
string connectClusterId = "";
// Make the request
Operation<ConnectCluster, OperationMetadata> response = managedKafkaConnectClient.CreateConnectCluster(parent, connectCluster, connectClusterId);

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

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ConnectCluster connectCluster = new ConnectCluster();
string connectClusterId = "";
// Make the request
Operation<ConnectCluster, OperationMetadata> response = await managedKafkaConnectClient.CreateConnectClusterAsync(parent, connectCluster, connectClusterId);

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

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ConnectCluster connectCluster = new ConnectCluster();
string connectClusterId = "";
// Make the request
Operation<ConnectCluster, OperationMetadata> response = await managedKafkaConnectClient.CreateConnectClusterAsync(parent, connectCluster, connectClusterId);

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

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
CreateConnectClusterRequest request = new CreateConnectClusterRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ConnectClusterId = "",
    ConnectCluster = new ConnectCluster(),
    RequestId = "",
};
// Make the request
Operation<ConnectCluster, OperationMetadata> response = await managedKafkaConnectClient.CreateConnectClusterAsync(request);

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

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
CreateConnectClusterRequest request = new CreateConnectClusterRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ConnectClusterId = "",
    ConnectCluster = new ConnectCluster(),
    RequestId = "",
};
// Make the request
Operation<ConnectCluster, OperationMetadata> response = await managedKafkaConnectClient.CreateConnectClusterAsync(request);

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

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ConnectCluster connectCluster = new ConnectCluster();
string connectClusterId = "";
// Make the request
Operation<ConnectCluster, OperationMetadata> response = await managedKafkaConnectClient.CreateConnectClusterAsync(parent, connectCluster, connectClusterId);

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

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ConnectCluster connectCluster = new ConnectCluster();
string connectClusterId = "";
// Make the request
Operation<ConnectCluster, OperationMetadata> response = await managedKafkaConnectClient.CreateConnectClusterAsync(parent, connectCluster, connectClusterId);

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

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
ConnectClusterName parent = ConnectClusterName.FromProjectLocationConnectCluster("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]");
Connector connector = new Connector();
string connectorId = "";
// Make the request
Connector response = managedKafkaConnectClient.CreateConnector(parent, connector, connectorId);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
CreateConnectorRequest request = new CreateConnectorRequest
{
    ParentAsConnectClusterName = ConnectClusterName.FromProjectLocationConnectCluster("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]"),
    ConnectorId = "",
    Connector = new Connector(),
};
// Make the request
Connector response = managedKafkaConnectClient.CreateConnector(request);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/connectClusters/[CONNECT_CLUSTER]";
Connector connector = new Connector();
string connectorId = "";
// Make the request
Connector response = managedKafkaConnectClient.CreateConnector(parent, connector, connectorId);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
ConnectClusterName parent = ConnectClusterName.FromProjectLocationConnectCluster("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]");
Connector connector = new Connector();
string connectorId = "";
// Make the request
Connector response = await managedKafkaConnectClient.CreateConnectorAsync(parent, connector, connectorId);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
ConnectClusterName parent = ConnectClusterName.FromProjectLocationConnectCluster("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]");
Connector connector = new Connector();
string connectorId = "";
// Make the request
Connector response = await managedKafkaConnectClient.CreateConnectorAsync(parent, connector, connectorId);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
CreateConnectorRequest request = new CreateConnectorRequest
{
    ParentAsConnectClusterName = ConnectClusterName.FromProjectLocationConnectCluster("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]"),
    ConnectorId = "",
    Connector = new Connector(),
};
// Make the request
Connector response = await managedKafkaConnectClient.CreateConnectorAsync(request);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
CreateConnectorRequest request = new CreateConnectorRequest
{
    ParentAsConnectClusterName = ConnectClusterName.FromProjectLocationConnectCluster("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]"),
    ConnectorId = "",
    Connector = new Connector(),
};
// Make the request
Connector response = await managedKafkaConnectClient.CreateConnectorAsync(request);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/connectClusters/[CONNECT_CLUSTER]";
Connector connector = new Connector();
string connectorId = "";
// Make the request
Connector response = await managedKafkaConnectClient.CreateConnectorAsync(parent, connector, connectorId);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/connectClusters/[CONNECT_CLUSTER]";
Connector connector = new Connector();
string connectorId = "";
// Make the request
Connector response = await managedKafkaConnectClient.CreateConnectorAsync(parent, connector, connectorId);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
ConnectClusterName name = ConnectClusterName.FromProjectLocationConnectCluster("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]");
// Make the request
Operation<Empty, OperationMetadata> response = managedKafkaConnectClient.DeleteConnectCluster(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 = managedKafkaConnectClient.PollOnceDeleteConnectCluster(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
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
DeleteConnectClusterRequest request = new DeleteConnectClusterRequest
{
    ConnectClusterName = ConnectClusterName.FromProjectLocationConnectCluster("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = managedKafkaConnectClient.DeleteConnectCluster(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 = managedKafkaConnectClient.PollOnceDeleteConnectCluster(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
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectClusters/[CONNECT_CLUSTER]";
// Make the request
Operation<Empty, OperationMetadata> response = managedKafkaConnectClient.DeleteConnectCluster(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 = managedKafkaConnectClient.PollOnceDeleteConnectCluster(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
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
ConnectClusterName name = ConnectClusterName.FromProjectLocationConnectCluster("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]");
// Make the request
Operation<Empty, OperationMetadata> response = await managedKafkaConnectClient.DeleteConnectClusterAsync(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 managedKafkaConnectClient.PollOnceDeleteConnectClusterAsync(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
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
ConnectClusterName name = ConnectClusterName.FromProjectLocationConnectCluster("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]");
// Make the request
Operation<Empty, OperationMetadata> response = await managedKafkaConnectClient.DeleteConnectClusterAsync(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 managedKafkaConnectClient.PollOnceDeleteConnectClusterAsync(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
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
DeleteConnectClusterRequest request = new DeleteConnectClusterRequest
{
    ConnectClusterName = ConnectClusterName.FromProjectLocationConnectCluster("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await managedKafkaConnectClient.DeleteConnectClusterAsync(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 managedKafkaConnectClient.PollOnceDeleteConnectClusterAsync(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
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
DeleteConnectClusterRequest request = new DeleteConnectClusterRequest
{
    ConnectClusterName = ConnectClusterName.FromProjectLocationConnectCluster("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await managedKafkaConnectClient.DeleteConnectClusterAsync(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 managedKafkaConnectClient.PollOnceDeleteConnectClusterAsync(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
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectClusters/[CONNECT_CLUSTER]";
// Make the request
Operation<Empty, OperationMetadata> response = await managedKafkaConnectClient.DeleteConnectClusterAsync(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 managedKafkaConnectClient.PollOnceDeleteConnectClusterAsync(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
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectClusters/[CONNECT_CLUSTER]";
// Make the request
Operation<Empty, OperationMetadata> response = await managedKafkaConnectClient.DeleteConnectClusterAsync(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 managedKafkaConnectClient.PollOnceDeleteConnectClusterAsync(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
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
ConnectorName name = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]");
// Make the request
managedKafkaConnectClient.DeleteConnector(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
DeleteConnectorRequest request = new DeleteConnectorRequest
{
    ConnectorName = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]"),
};
// Make the request
managedKafkaConnectClient.DeleteConnector(request);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectClusters/[CONNECT_CLUSTER]/connectors/[CONNECTOR]";
// Make the request
managedKafkaConnectClient.DeleteConnector(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
ConnectorName name = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]");
// Make the request
await managedKafkaConnectClient.DeleteConnectorAsync(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
ConnectorName name = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]");
// Make the request
await managedKafkaConnectClient.DeleteConnectorAsync(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
DeleteConnectorRequest request = new DeleteConnectorRequest
{
    ConnectorName = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]"),
};
// Make the request
await managedKafkaConnectClient.DeleteConnectorAsync(request);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
DeleteConnectorRequest request = new DeleteConnectorRequest
{
    ConnectorName = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]"),
};
// Make the request
await managedKafkaConnectClient.DeleteConnectorAsync(request);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectClusters/[CONNECT_CLUSTER]/connectors/[CONNECTOR]";
// Make the request
await managedKafkaConnectClient.DeleteConnectorAsync(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectClusters/[CONNECT_CLUSTER]/connectors/[CONNECTOR]";
// Make the request
await managedKafkaConnectClient.DeleteConnectorAsync(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
ConnectClusterName name = ConnectClusterName.FromProjectLocationConnectCluster("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]");
// Make the request
ConnectCluster response = managedKafkaConnectClient.GetConnectCluster(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
GetConnectClusterRequest request = new GetConnectClusterRequest
{
    ConnectClusterName = ConnectClusterName.FromProjectLocationConnectCluster("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]"),
};
// Make the request
ConnectCluster response = managedKafkaConnectClient.GetConnectCluster(request);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectClusters/[CONNECT_CLUSTER]";
// Make the request
ConnectCluster response = managedKafkaConnectClient.GetConnectCluster(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
ConnectClusterName name = ConnectClusterName.FromProjectLocationConnectCluster("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]");
// Make the request
ConnectCluster response = await managedKafkaConnectClient.GetConnectClusterAsync(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
ConnectClusterName name = ConnectClusterName.FromProjectLocationConnectCluster("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]");
// Make the request
ConnectCluster response = await managedKafkaConnectClient.GetConnectClusterAsync(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
GetConnectClusterRequest request = new GetConnectClusterRequest
{
    ConnectClusterName = ConnectClusterName.FromProjectLocationConnectCluster("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]"),
};
// Make the request
ConnectCluster response = await managedKafkaConnectClient.GetConnectClusterAsync(request);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
GetConnectClusterRequest request = new GetConnectClusterRequest
{
    ConnectClusterName = ConnectClusterName.FromProjectLocationConnectCluster("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]"),
};
// Make the request
ConnectCluster response = await managedKafkaConnectClient.GetConnectClusterAsync(request);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectClusters/[CONNECT_CLUSTER]";
// Make the request
ConnectCluster response = await managedKafkaConnectClient.GetConnectClusterAsync(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectClusters/[CONNECT_CLUSTER]";
// Make the request
ConnectCluster response = await managedKafkaConnectClient.GetConnectClusterAsync(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
ConnectorName name = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]");
// Make the request
Connector response = managedKafkaConnectClient.GetConnector(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
GetConnectorRequest request = new GetConnectorRequest
{
    ConnectorName = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]"),
};
// Make the request
Connector response = managedKafkaConnectClient.GetConnector(request);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectClusters/[CONNECT_CLUSTER]/connectors/[CONNECTOR]";
// Make the request
Connector response = managedKafkaConnectClient.GetConnector(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
ConnectorName name = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]");
// Make the request
Connector response = await managedKafkaConnectClient.GetConnectorAsync(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
ConnectorName name = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]");
// Make the request
Connector response = await managedKafkaConnectClient.GetConnectorAsync(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
GetConnectorRequest request = new GetConnectorRequest
{
    ConnectorName = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]"),
};
// Make the request
Connector response = await managedKafkaConnectClient.GetConnectorAsync(request);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
GetConnectorRequest request = new GetConnectorRequest
{
    ConnectorName = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]"),
};
// Make the request
Connector response = await managedKafkaConnectClient.GetConnectorAsync(request);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectClusters/[CONNECT_CLUSTER]/connectors/[CONNECTOR]";
// Make the request
Connector response = await managedKafkaConnectClient.GetConnectorAsync(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectClusters/[CONNECT_CLUSTER]/connectors/[CONNECTOR]";
// Make the request
Connector response = await managedKafkaConnectClient.GetConnectorAsync(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListConnectClustersResponse, ConnectCluster> response = managedKafkaConnectClient.ListConnectClusters(parent);

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

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

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

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

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

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((ConnectCluster 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((ListConnectClustersResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ConnectCluster 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<ConnectCluster> 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 (ConnectCluster 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
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
ConnectClusterName parent = ConnectClusterName.FromProjectLocationConnectCluster("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]");
// Make the request
PagedEnumerable<ListConnectorsResponse, Connector> response = managedKafkaConnectClient.ListConnectors(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Connector 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 (ListConnectorsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Connector 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<Connector> 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 (Connector 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
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
ListConnectorsRequest request = new ListConnectorsRequest
{
    ParentAsConnectClusterName = ConnectClusterName.FromProjectLocationConnectCluster("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]"),
};
// Make the request
PagedEnumerable<ListConnectorsResponse, Connector> response = managedKafkaConnectClient.ListConnectors(request);

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

// Iterate over all response items, lazily performing RPCs as required
foreach (Connector 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 (ListConnectorsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Connector 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<Connector> 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 (Connector 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
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
ConnectClusterName parent = ConnectClusterName.FromProjectLocationConnectCluster("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]");
// Make the request
PagedAsyncEnumerable<ListConnectorsResponse, Connector> response = managedKafkaConnectClient.ListConnectorsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Connector 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((ListConnectorsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Connector 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<Connector> 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 (Connector 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
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
ListConnectorsRequest request = new ListConnectorsRequest
{
    ParentAsConnectClusterName = ConnectClusterName.FromProjectLocationConnectCluster("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]"),
};
// Make the request
PagedAsyncEnumerable<ListConnectorsResponse, Connector> response = managedKafkaConnectClient.ListConnectorsAsync(request);

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

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Connector 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((ListConnectorsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Connector 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<Connector> 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 (Connector 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
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
ConnectorName name = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]");
// Make the request
PauseConnectorResponse response = managedKafkaConnectClient.PauseConnector(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
PauseConnectorRequest request = new PauseConnectorRequest
{
    ConnectorName = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]"),
};
// Make the request
PauseConnectorResponse response = managedKafkaConnectClient.PauseConnector(request);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectClusters/[CONNECT_CLUSTER]/connectors/[CONNECTOR]";
// Make the request
PauseConnectorResponse response = managedKafkaConnectClient.PauseConnector(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
ConnectorName name = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]");
// Make the request
PauseConnectorResponse response = await managedKafkaConnectClient.PauseConnectorAsync(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
ConnectorName name = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]");
// Make the request
PauseConnectorResponse response = await managedKafkaConnectClient.PauseConnectorAsync(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
PauseConnectorRequest request = new PauseConnectorRequest
{
    ConnectorName = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]"),
};
// Make the request
PauseConnectorResponse response = await managedKafkaConnectClient.PauseConnectorAsync(request);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
PauseConnectorRequest request = new PauseConnectorRequest
{
    ConnectorName = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]"),
};
// Make the request
PauseConnectorResponse response = await managedKafkaConnectClient.PauseConnectorAsync(request);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectClusters/[CONNECT_CLUSTER]/connectors/[CONNECTOR]";
// Make the request
PauseConnectorResponse response = await managedKafkaConnectClient.PauseConnectorAsync(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectClusters/[CONNECT_CLUSTER]/connectors/[CONNECTOR]";
// Make the request
PauseConnectorResponse response = await managedKafkaConnectClient.PauseConnectorAsync(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
ConnectorName name = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]");
// Make the request
RestartConnectorResponse response = managedKafkaConnectClient.RestartConnector(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
RestartConnectorRequest request = new RestartConnectorRequest
{
    ConnectorName = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]"),
};
// Make the request
RestartConnectorResponse response = managedKafkaConnectClient.RestartConnector(request);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectClusters/[CONNECT_CLUSTER]/connectors/[CONNECTOR]";
// Make the request
RestartConnectorResponse response = managedKafkaConnectClient.RestartConnector(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
ConnectorName name = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]");
// Make the request
RestartConnectorResponse response = await managedKafkaConnectClient.RestartConnectorAsync(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
ConnectorName name = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]");
// Make the request
RestartConnectorResponse response = await managedKafkaConnectClient.RestartConnectorAsync(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
RestartConnectorRequest request = new RestartConnectorRequest
{
    ConnectorName = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]"),
};
// Make the request
RestartConnectorResponse response = await managedKafkaConnectClient.RestartConnectorAsync(request);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
RestartConnectorRequest request = new RestartConnectorRequest
{
    ConnectorName = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]"),
};
// Make the request
RestartConnectorResponse response = await managedKafkaConnectClient.RestartConnectorAsync(request);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectClusters/[CONNECT_CLUSTER]/connectors/[CONNECTOR]";
// Make the request
RestartConnectorResponse response = await managedKafkaConnectClient.RestartConnectorAsync(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectClusters/[CONNECT_CLUSTER]/connectors/[CONNECTOR]";
// Make the request
RestartConnectorResponse response = await managedKafkaConnectClient.RestartConnectorAsync(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
ConnectorName name = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]");
// Make the request
ResumeConnectorResponse response = managedKafkaConnectClient.ResumeConnector(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
ResumeConnectorRequest request = new ResumeConnectorRequest
{
    ConnectorName = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]"),
};
// Make the request
ResumeConnectorResponse response = managedKafkaConnectClient.ResumeConnector(request);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectClusters/[CONNECT_CLUSTER]/connectors/[CONNECTOR]";
// Make the request
ResumeConnectorResponse response = managedKafkaConnectClient.ResumeConnector(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
ConnectorName name = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]");
// Make the request
ResumeConnectorResponse response = await managedKafkaConnectClient.ResumeConnectorAsync(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
ConnectorName name = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]");
// Make the request
ResumeConnectorResponse response = await managedKafkaConnectClient.ResumeConnectorAsync(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
ResumeConnectorRequest request = new ResumeConnectorRequest
{
    ConnectorName = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]"),
};
// Make the request
ResumeConnectorResponse response = await managedKafkaConnectClient.ResumeConnectorAsync(request);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
ResumeConnectorRequest request = new ResumeConnectorRequest
{
    ConnectorName = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]"),
};
// Make the request
ResumeConnectorResponse response = await managedKafkaConnectClient.ResumeConnectorAsync(request);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectClusters/[CONNECT_CLUSTER]/connectors/[CONNECTOR]";
// Make the request
ResumeConnectorResponse response = await managedKafkaConnectClient.ResumeConnectorAsync(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectClusters/[CONNECT_CLUSTER]/connectors/[CONNECTOR]";
// Make the request
ResumeConnectorResponse response = await managedKafkaConnectClient.ResumeConnectorAsync(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
ConnectorName name = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]");
// Make the request
StopConnectorResponse response = managedKafkaConnectClient.StopConnector(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
StopConnectorRequest request = new StopConnectorRequest
{
    ConnectorName = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]"),
};
// Make the request
StopConnectorResponse response = managedKafkaConnectClient.StopConnector(request);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectClusters/[CONNECT_CLUSTER]/connectors/[CONNECTOR]";
// Make the request
StopConnectorResponse response = managedKafkaConnectClient.StopConnector(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
ConnectorName name = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]");
// Make the request
StopConnectorResponse response = await managedKafkaConnectClient.StopConnectorAsync(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
ConnectorName name = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]");
// Make the request
StopConnectorResponse response = await managedKafkaConnectClient.StopConnectorAsync(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
StopConnectorRequest request = new StopConnectorRequest
{
    ConnectorName = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]"),
};
// Make the request
StopConnectorResponse response = await managedKafkaConnectClient.StopConnectorAsync(request);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
StopConnectorRequest request = new StopConnectorRequest
{
    ConnectorName = ConnectorName.FromProjectLocationConnectClusterConnector("[PROJECT]", "[LOCATION]", "[CONNECT_CLUSTER]", "[CONNECTOR]"),
};
// Make the request
StopConnectorResponse response = await managedKafkaConnectClient.StopConnectorAsync(request);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectClusters/[CONNECT_CLUSTER]/connectors/[CONNECTOR]";
// Make the request
StopConnectorResponse response = await managedKafkaConnectClient.StopConnectorAsync(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectClusters/[CONNECT_CLUSTER]/connectors/[CONNECTOR]";
// Make the request
StopConnectorResponse response = await managedKafkaConnectClient.StopConnectorAsync(name);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
ConnectCluster connectCluster = new ConnectCluster();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<ConnectCluster, OperationMetadata> response = managedKafkaConnectClient.UpdateConnectCluster(connectCluster, updateMask);

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

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
UpdateConnectClusterRequest request = new UpdateConnectClusterRequest
{
    UpdateMask = new FieldMask(),
    ConnectCluster = new ConnectCluster(),
    RequestId = "",
};
// Make the request
Operation<ConnectCluster, OperationMetadata> response = managedKafkaConnectClient.UpdateConnectCluster(request);

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

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
ConnectCluster connectCluster = new ConnectCluster();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<ConnectCluster, OperationMetadata> response = await managedKafkaConnectClient.UpdateConnectClusterAsync(connectCluster, updateMask);

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

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
ConnectCluster connectCluster = new ConnectCluster();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<ConnectCluster, OperationMetadata> response = await managedKafkaConnectClient.UpdateConnectClusterAsync(connectCluster, updateMask);

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

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
UpdateConnectClusterRequest request = new UpdateConnectClusterRequest
{
    UpdateMask = new FieldMask(),
    ConnectCluster = new ConnectCluster(),
    RequestId = "",
};
// Make the request
Operation<ConnectCluster, OperationMetadata> response = await managedKafkaConnectClient.UpdateConnectClusterAsync(request);

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

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
UpdateConnectClusterRequest request = new UpdateConnectClusterRequest
{
    UpdateMask = new FieldMask(),
    ConnectCluster = new ConnectCluster(),
    RequestId = "",
};
// Make the request
Operation<ConnectCluster, OperationMetadata> response = await managedKafkaConnectClient.UpdateConnectClusterAsync(request);

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

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
Connector connector = new Connector();
FieldMask updateMask = new FieldMask();
// Make the request
Connector response = managedKafkaConnectClient.UpdateConnector(connector, updateMask);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.Create();
// Initialize request argument(s)
UpdateConnectorRequest request = new UpdateConnectorRequest
{
    UpdateMask = new FieldMask(),
    Connector = new Connector(),
};
// Make the request
Connector response = managedKafkaConnectClient.UpdateConnector(request);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
Connector connector = new Connector();
FieldMask updateMask = new FieldMask();
// Make the request
Connector response = await managedKafkaConnectClient.UpdateConnectorAsync(connector, updateMask);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
Connector connector = new Connector();
FieldMask updateMask = new FieldMask();
// Make the request
Connector response = await managedKafkaConnectClient.UpdateConnectorAsync(connector, updateMask);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
UpdateConnectorRequest request = new UpdateConnectorRequest
{
    UpdateMask = new FieldMask(),
    Connector = new Connector(),
};
// Make the request
Connector response = await managedKafkaConnectClient.UpdateConnectorAsync(request);

// Create client
ManagedKafkaConnectClient managedKafkaConnectClient = await ManagedKafkaConnectClient.CreateAsync();
// Initialize request argument(s)
UpdateConnectorRequest request = new UpdateConnectorRequest
{
    UpdateMask = new FieldMask(),
    Connector = new Connector(),
};
// Make the request
Connector response = await managedKafkaConnectClient.UpdateConnectorAsync(request);