Developer Connect v1 API - Class DeveloperConnectClient (1.0.0-beta01)

// Create client
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Connection connection = new Connection();
string connectionId = "";
// Make the request
Operation<Connection, OperationMetadata> response = developerConnectClient.CreateConnection(parent, connection, connectionId);

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

// Create client
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
CreateConnectionRequest request = new CreateConnectionRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ConnectionId = "",
    Connection = new Connection(),
    RequestId = "",
    ValidateOnly = false,
};
// Make the request
Operation<Connection, OperationMetadata> response = developerConnectClient.CreateConnection(request);

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

// Create client
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Connection connection = new Connection();
string connectionId = "";
// Make the request
Operation<Connection, OperationMetadata> response = developerConnectClient.CreateConnection(parent, connection, connectionId);

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

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Connection connection = new Connection();
string connectionId = "";
// Make the request
Operation<Connection, OperationMetadata> response = await developerConnectClient.CreateConnectionAsync(parent, connection, connectionId);

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

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Connection connection = new Connection();
string connectionId = "";
// Make the request
Operation<Connection, OperationMetadata> response = await developerConnectClient.CreateConnectionAsync(parent, connection, connectionId);

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

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
CreateConnectionRequest request = new CreateConnectionRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ConnectionId = "",
    Connection = new Connection(),
    RequestId = "",
    ValidateOnly = false,
};
// Make the request
Operation<Connection, OperationMetadata> response = await developerConnectClient.CreateConnectionAsync(request);

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

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
CreateConnectionRequest request = new CreateConnectionRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ConnectionId = "",
    Connection = new Connection(),
    RequestId = "",
    ValidateOnly = false,
};
// Make the request
Operation<Connection, OperationMetadata> response = await developerConnectClient.CreateConnectionAsync(request);

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

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Connection connection = new Connection();
string connectionId = "";
// Make the request
Operation<Connection, OperationMetadata> response = await developerConnectClient.CreateConnectionAsync(parent, connection, connectionId);

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

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Connection connection = new Connection();
string connectionId = "";
// Make the request
Operation<Connection, OperationMetadata> response = await developerConnectClient.CreateConnectionAsync(parent, connection, connectionId);

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

// Create client
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
ConnectionName parent = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]");
GitRepositoryLink gitRepositoryLink = new GitRepositoryLink();
string gitRepositoryLinkId = "";
// Make the request
Operation<GitRepositoryLink, OperationMetadata> response = developerConnectClient.CreateGitRepositoryLink(parent, gitRepositoryLink, gitRepositoryLinkId);

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

// Create client
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
CreateGitRepositoryLinkRequest request = new CreateGitRepositoryLinkRequest
{
    ParentAsConnectionName = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]"),
    GitRepositoryLink = new GitRepositoryLink(),
    GitRepositoryLinkId = "",
    RequestId = "",
    ValidateOnly = false,
};
// Make the request
Operation<GitRepositoryLink, OperationMetadata> response = developerConnectClient.CreateGitRepositoryLink(request);

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

// Create client
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/connections/[CONNECTION]";
GitRepositoryLink gitRepositoryLink = new GitRepositoryLink();
string gitRepositoryLinkId = "";
// Make the request
Operation<GitRepositoryLink, OperationMetadata> response = developerConnectClient.CreateGitRepositoryLink(parent, gitRepositoryLink, gitRepositoryLinkId);

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

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
ConnectionName parent = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]");
GitRepositoryLink gitRepositoryLink = new GitRepositoryLink();
string gitRepositoryLinkId = "";
// Make the request
Operation<GitRepositoryLink, OperationMetadata> response = await developerConnectClient.CreateGitRepositoryLinkAsync(parent, gitRepositoryLink, gitRepositoryLinkId);

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

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
ConnectionName parent = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]");
GitRepositoryLink gitRepositoryLink = new GitRepositoryLink();
string gitRepositoryLinkId = "";
// Make the request
Operation<GitRepositoryLink, OperationMetadata> response = await developerConnectClient.CreateGitRepositoryLinkAsync(parent, gitRepositoryLink, gitRepositoryLinkId);

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

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
CreateGitRepositoryLinkRequest request = new CreateGitRepositoryLinkRequest
{
    ParentAsConnectionName = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]"),
    GitRepositoryLink = new GitRepositoryLink(),
    GitRepositoryLinkId = "",
    RequestId = "",
    ValidateOnly = false,
};
// Make the request
Operation<GitRepositoryLink, OperationMetadata> response = await developerConnectClient.CreateGitRepositoryLinkAsync(request);

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

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
CreateGitRepositoryLinkRequest request = new CreateGitRepositoryLinkRequest
{
    ParentAsConnectionName = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]"),
    GitRepositoryLink = new GitRepositoryLink(),
    GitRepositoryLinkId = "",
    RequestId = "",
    ValidateOnly = false,
};
// Make the request
Operation<GitRepositoryLink, OperationMetadata> response = await developerConnectClient.CreateGitRepositoryLinkAsync(request);

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

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/connections/[CONNECTION]";
GitRepositoryLink gitRepositoryLink = new GitRepositoryLink();
string gitRepositoryLinkId = "";
// Make the request
Operation<GitRepositoryLink, OperationMetadata> response = await developerConnectClient.CreateGitRepositoryLinkAsync(parent, gitRepositoryLink, gitRepositoryLinkId);

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

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/connections/[CONNECTION]";
GitRepositoryLink gitRepositoryLink = new GitRepositoryLink();
string gitRepositoryLinkId = "";
// Make the request
Operation<GitRepositoryLink, OperationMetadata> response = await developerConnectClient.CreateGitRepositoryLinkAsync(parent, gitRepositoryLink, gitRepositoryLinkId);

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

// Create client
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
ConnectionName name = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]");
// Make the request
Operation<Empty, OperationMetadata> response = developerConnectClient.DeleteConnection(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 = developerConnectClient.PollOnceDeleteConnection(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
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
DeleteConnectionRequest request = new DeleteConnectionRequest
{
    ConnectionName = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]"),
    RequestId = "",
    ValidateOnly = false,
    Etag = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = developerConnectClient.DeleteConnection(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 = developerConnectClient.PollOnceDeleteConnection(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
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connections/[CONNECTION]";
// Make the request
Operation<Empty, OperationMetadata> response = developerConnectClient.DeleteConnection(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 = developerConnectClient.PollOnceDeleteConnection(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
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
ConnectionName name = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]");
// Make the request
Operation<Empty, OperationMetadata> response = await developerConnectClient.DeleteConnectionAsync(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 developerConnectClient.PollOnceDeleteConnectionAsync(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
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
ConnectionName name = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]");
// Make the request
Operation<Empty, OperationMetadata> response = await developerConnectClient.DeleteConnectionAsync(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 developerConnectClient.PollOnceDeleteConnectionAsync(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
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
DeleteConnectionRequest request = new DeleteConnectionRequest
{
    ConnectionName = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]"),
    RequestId = "",
    ValidateOnly = false,
    Etag = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await developerConnectClient.DeleteConnectionAsync(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 developerConnectClient.PollOnceDeleteConnectionAsync(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
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
DeleteConnectionRequest request = new DeleteConnectionRequest
{
    ConnectionName = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]"),
    RequestId = "",
    ValidateOnly = false,
    Etag = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await developerConnectClient.DeleteConnectionAsync(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 developerConnectClient.PollOnceDeleteConnectionAsync(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
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connections/[CONNECTION]";
// Make the request
Operation<Empty, OperationMetadata> response = await developerConnectClient.DeleteConnectionAsync(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 developerConnectClient.PollOnceDeleteConnectionAsync(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
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connections/[CONNECTION]";
// Make the request
Operation<Empty, OperationMetadata> response = await developerConnectClient.DeleteConnectionAsync(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 developerConnectClient.PollOnceDeleteConnectionAsync(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
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
DeleteGitRepositoryLinkRequest request = new DeleteGitRepositoryLinkRequest
{
    GitRepositoryLinkName = GitRepositoryLinkName.FromProjectLocationConnectionGitRepositoryLink("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[GIT_REPOSITORY_LINK]"),
    RequestId = "",
    ValidateOnly = false,
    Etag = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = developerConnectClient.DeleteGitRepositoryLink(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 = developerConnectClient.PollOnceDeleteGitRepositoryLink(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
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
GitRepositoryLinkName name = GitRepositoryLinkName.FromProjectLocationConnectionGitRepositoryLink("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[GIT_REPOSITORY_LINK]");
// Make the request
Operation<Empty, OperationMetadata> response = developerConnectClient.DeleteGitRepositoryLink(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 = developerConnectClient.PollOnceDeleteGitRepositoryLink(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
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connections/[CONNECTION]/gitRepositoryLinks/[GIT_REPOSITORY_LINK]";
// Make the request
Operation<Empty, OperationMetadata> response = developerConnectClient.DeleteGitRepositoryLink(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 = developerConnectClient.PollOnceDeleteGitRepositoryLink(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
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
DeleteGitRepositoryLinkRequest request = new DeleteGitRepositoryLinkRequest
{
    GitRepositoryLinkName = GitRepositoryLinkName.FromProjectLocationConnectionGitRepositoryLink("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[GIT_REPOSITORY_LINK]"),
    RequestId = "",
    ValidateOnly = false,
    Etag = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await developerConnectClient.DeleteGitRepositoryLinkAsync(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 developerConnectClient.PollOnceDeleteGitRepositoryLinkAsync(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
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
DeleteGitRepositoryLinkRequest request = new DeleteGitRepositoryLinkRequest
{
    GitRepositoryLinkName = GitRepositoryLinkName.FromProjectLocationConnectionGitRepositoryLink("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[GIT_REPOSITORY_LINK]"),
    RequestId = "",
    ValidateOnly = false,
    Etag = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await developerConnectClient.DeleteGitRepositoryLinkAsync(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 developerConnectClient.PollOnceDeleteGitRepositoryLinkAsync(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
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
GitRepositoryLinkName name = GitRepositoryLinkName.FromProjectLocationConnectionGitRepositoryLink("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[GIT_REPOSITORY_LINK]");
// Make the request
Operation<Empty, OperationMetadata> response = await developerConnectClient.DeleteGitRepositoryLinkAsync(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 developerConnectClient.PollOnceDeleteGitRepositoryLinkAsync(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
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
GitRepositoryLinkName name = GitRepositoryLinkName.FromProjectLocationConnectionGitRepositoryLink("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[GIT_REPOSITORY_LINK]");
// Make the request
Operation<Empty, OperationMetadata> response = await developerConnectClient.DeleteGitRepositoryLinkAsync(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 developerConnectClient.PollOnceDeleteGitRepositoryLinkAsync(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
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connections/[CONNECTION]/gitRepositoryLinks/[GIT_REPOSITORY_LINK]";
// Make the request
Operation<Empty, OperationMetadata> response = await developerConnectClient.DeleteGitRepositoryLinkAsync(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 developerConnectClient.PollOnceDeleteGitRepositoryLinkAsync(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
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connections/[CONNECTION]/gitRepositoryLinks/[GIT_REPOSITORY_LINK]";
// Make the request
Operation<Empty, OperationMetadata> response = await developerConnectClient.DeleteGitRepositoryLinkAsync(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 developerConnectClient.PollOnceDeleteGitRepositoryLinkAsync(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
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
ConnectionName connection = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]");
// Make the request
FetchGitHubInstallationsResponse response = developerConnectClient.FetchGitHubInstallations(connection);

// Create client
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
FetchGitHubInstallationsRequest request = new FetchGitHubInstallationsRequest
{
    ConnectionAsConnectionName = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]"),
};
// Make the request
FetchGitHubInstallationsResponse response = developerConnectClient.FetchGitHubInstallations(request);

// Create client
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
string connection = "projects/[PROJECT]/locations/[LOCATION]/connections/[CONNECTION]";
// Make the request
FetchGitHubInstallationsResponse response = developerConnectClient.FetchGitHubInstallations(connection);

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
ConnectionName connection = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]");
// Make the request
FetchGitHubInstallationsResponse response = await developerConnectClient.FetchGitHubInstallationsAsync(connection);

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
ConnectionName connection = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]");
// Make the request
FetchGitHubInstallationsResponse response = await developerConnectClient.FetchGitHubInstallationsAsync(connection);

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
FetchGitHubInstallationsRequest request = new FetchGitHubInstallationsRequest
{
    ConnectionAsConnectionName = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]"),
};
// Make the request
FetchGitHubInstallationsResponse response = await developerConnectClient.FetchGitHubInstallationsAsync(request);

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
FetchGitHubInstallationsRequest request = new FetchGitHubInstallationsRequest
{
    ConnectionAsConnectionName = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]"),
};
// Make the request
FetchGitHubInstallationsResponse response = await developerConnectClient.FetchGitHubInstallationsAsync(request);

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
string connection = "projects/[PROJECT]/locations/[LOCATION]/connections/[CONNECTION]";
// Make the request
FetchGitHubInstallationsResponse response = await developerConnectClient.FetchGitHubInstallationsAsync(connection);

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
string connection = "projects/[PROJECT]/locations/[LOCATION]/connections/[CONNECTION]";
// Make the request
FetchGitHubInstallationsResponse response = await developerConnectClient.FetchGitHubInstallationsAsync(connection);

// Create client
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
FetchGitRefsRequest request = new FetchGitRefsRequest
{
    GitRepositoryLinkAsGitRepositoryLinkName = GitRepositoryLinkName.FromProjectLocationConnectionGitRepositoryLink("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[GIT_REPOSITORY_LINK]"),
    RefType = FetchGitRefsRequest.Types.RefType.Unspecified,
};
// Make the request
PagedEnumerable<FetchGitRefsResponse, string> response = developerConnectClient.FetchGitRefs(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (string 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 (FetchGitRefsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (string 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<string> 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 (string 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
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
GitRepositoryLinkName gitRepositoryLink = GitRepositoryLinkName.FromProjectLocationConnectionGitRepositoryLink("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[GIT_REPOSITORY_LINK]");
FetchGitRefsRequest.Types.RefType refType = FetchGitRefsRequest.Types.RefType.Unspecified;
// Make the request
PagedEnumerable<FetchGitRefsResponse, string> response = developerConnectClient.FetchGitRefs(gitRepositoryLink, refType);

// Iterate over all response items, lazily performing RPCs as required
foreach (string 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 (FetchGitRefsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (string 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<string> 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 (string 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
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
string gitRepositoryLink = "projects/[PROJECT]/locations/[LOCATION]/connections/[CONNECTION]/gitRepositoryLinks/[GIT_REPOSITORY_LINK]";
FetchGitRefsRequest.Types.RefType refType = FetchGitRefsRequest.Types.RefType.Unspecified;
// Make the request
PagedEnumerable<FetchGitRefsResponse, string> response = developerConnectClient.FetchGitRefs(gitRepositoryLink, refType);

// Iterate over all response items, lazily performing RPCs as required
foreach (string 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 (FetchGitRefsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (string 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<string> 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 (string 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
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
FetchGitRefsRequest request = new FetchGitRefsRequest
{
    GitRepositoryLinkAsGitRepositoryLinkName = GitRepositoryLinkName.FromProjectLocationConnectionGitRepositoryLink("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[GIT_REPOSITORY_LINK]"),
    RefType = FetchGitRefsRequest.Types.RefType.Unspecified,
};
// Make the request
PagedAsyncEnumerable<FetchGitRefsResponse, string> response = developerConnectClient.FetchGitRefsAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((string 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((FetchGitRefsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (string 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<string> 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 (string 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
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
GitRepositoryLinkName gitRepositoryLink = GitRepositoryLinkName.FromProjectLocationConnectionGitRepositoryLink("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[GIT_REPOSITORY_LINK]");
FetchGitRefsRequest.Types.RefType refType = FetchGitRefsRequest.Types.RefType.Unspecified;
// Make the request
PagedAsyncEnumerable<FetchGitRefsResponse, string> response = developerConnectClient.FetchGitRefsAsync(gitRepositoryLink, refType);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((string 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((FetchGitRefsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (string 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<string> 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 (string 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
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
string gitRepositoryLink = "projects/[PROJECT]/locations/[LOCATION]/connections/[CONNECTION]/gitRepositoryLinks/[GIT_REPOSITORY_LINK]";
FetchGitRefsRequest.Types.RefType refType = FetchGitRefsRequest.Types.RefType.Unspecified;
// Make the request
PagedAsyncEnumerable<FetchGitRefsResponse, string> response = developerConnectClient.FetchGitRefsAsync(gitRepositoryLink, refType);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((string 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((FetchGitRefsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (string 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<string> 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 (string 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
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
ConnectionName connection = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]");
// Make the request
PagedEnumerable<FetchLinkableGitRepositoriesResponse, LinkableGitRepository> response = developerConnectClient.FetchLinkableGitRepositories(connection);

// Iterate over all response items, lazily performing RPCs as required
foreach (LinkableGitRepository 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 (FetchLinkableGitRepositoriesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (LinkableGitRepository 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<LinkableGitRepository> 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 (LinkableGitRepository 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
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
FetchLinkableGitRepositoriesRequest request = new FetchLinkableGitRepositoriesRequest
{
    ConnectionAsConnectionName = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]"),
};
// Make the request
PagedEnumerable<FetchLinkableGitRepositoriesResponse, LinkableGitRepository> response = developerConnectClient.FetchLinkableGitRepositories(request);

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

// Iterate over all response items, lazily performing RPCs as required
foreach (LinkableGitRepository 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 (FetchLinkableGitRepositoriesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (LinkableGitRepository 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<LinkableGitRepository> 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 (LinkableGitRepository 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
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
ConnectionName connection = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]");
// Make the request
PagedAsyncEnumerable<FetchLinkableGitRepositoriesResponse, LinkableGitRepository> response = developerConnectClient.FetchLinkableGitRepositoriesAsync(connection);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((LinkableGitRepository 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((FetchLinkableGitRepositoriesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (LinkableGitRepository 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<LinkableGitRepository> 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 (LinkableGitRepository 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
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
FetchLinkableGitRepositoriesRequest request = new FetchLinkableGitRepositoriesRequest
{
    ConnectionAsConnectionName = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]"),
};
// Make the request
PagedAsyncEnumerable<FetchLinkableGitRepositoriesResponse, LinkableGitRepository> response = developerConnectClient.FetchLinkableGitRepositoriesAsync(request);

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

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((LinkableGitRepository 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((FetchLinkableGitRepositoriesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (LinkableGitRepository 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<LinkableGitRepository> 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 (LinkableGitRepository 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
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
FetchReadTokenRequest request = new FetchReadTokenRequest
{
    GitRepositoryLinkAsGitRepositoryLinkName = GitRepositoryLinkName.FromProjectLocationConnectionGitRepositoryLink("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[GIT_REPOSITORY_LINK]"),
};
// Make the request
FetchReadTokenResponse response = developerConnectClient.FetchReadToken(request);

// Create client
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
GitRepositoryLinkName gitRepositoryLink = GitRepositoryLinkName.FromProjectLocationConnectionGitRepositoryLink("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[GIT_REPOSITORY_LINK]");
// Make the request
FetchReadTokenResponse response = developerConnectClient.FetchReadToken(gitRepositoryLink);

// Create client
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
string gitRepositoryLink = "projects/[PROJECT]/locations/[LOCATION]/connections/[CONNECTION]/gitRepositoryLinks/[GIT_REPOSITORY_LINK]";
// Make the request
FetchReadTokenResponse response = developerConnectClient.FetchReadToken(gitRepositoryLink);

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
FetchReadTokenRequest request = new FetchReadTokenRequest
{
    GitRepositoryLinkAsGitRepositoryLinkName = GitRepositoryLinkName.FromProjectLocationConnectionGitRepositoryLink("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[GIT_REPOSITORY_LINK]"),
};
// Make the request
FetchReadTokenResponse response = await developerConnectClient.FetchReadTokenAsync(request);

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
FetchReadTokenRequest request = new FetchReadTokenRequest
{
    GitRepositoryLinkAsGitRepositoryLinkName = GitRepositoryLinkName.FromProjectLocationConnectionGitRepositoryLink("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[GIT_REPOSITORY_LINK]"),
};
// Make the request
FetchReadTokenResponse response = await developerConnectClient.FetchReadTokenAsync(request);

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
GitRepositoryLinkName gitRepositoryLink = GitRepositoryLinkName.FromProjectLocationConnectionGitRepositoryLink("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[GIT_REPOSITORY_LINK]");
// Make the request
FetchReadTokenResponse response = await developerConnectClient.FetchReadTokenAsync(gitRepositoryLink);

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
GitRepositoryLinkName gitRepositoryLink = GitRepositoryLinkName.FromProjectLocationConnectionGitRepositoryLink("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[GIT_REPOSITORY_LINK]");
// Make the request
FetchReadTokenResponse response = await developerConnectClient.FetchReadTokenAsync(gitRepositoryLink);

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
string gitRepositoryLink = "projects/[PROJECT]/locations/[LOCATION]/connections/[CONNECTION]/gitRepositoryLinks/[GIT_REPOSITORY_LINK]";
// Make the request
FetchReadTokenResponse response = await developerConnectClient.FetchReadTokenAsync(gitRepositoryLink);

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
string gitRepositoryLink = "projects/[PROJECT]/locations/[LOCATION]/connections/[CONNECTION]/gitRepositoryLinks/[GIT_REPOSITORY_LINK]";
// Make the request
FetchReadTokenResponse response = await developerConnectClient.FetchReadTokenAsync(gitRepositoryLink);

// Create client
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
FetchReadWriteTokenRequest request = new FetchReadWriteTokenRequest
{
    GitRepositoryLinkAsGitRepositoryLinkName = GitRepositoryLinkName.FromProjectLocationConnectionGitRepositoryLink("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[GIT_REPOSITORY_LINK]"),
};
// Make the request
FetchReadWriteTokenResponse response = developerConnectClient.FetchReadWriteToken(request);

// Create client
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
GitRepositoryLinkName gitRepositoryLink = GitRepositoryLinkName.FromProjectLocationConnectionGitRepositoryLink("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[GIT_REPOSITORY_LINK]");
// Make the request
FetchReadWriteTokenResponse response = developerConnectClient.FetchReadWriteToken(gitRepositoryLink);

// Create client
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
string gitRepositoryLink = "projects/[PROJECT]/locations/[LOCATION]/connections/[CONNECTION]/gitRepositoryLinks/[GIT_REPOSITORY_LINK]";
// Make the request
FetchReadWriteTokenResponse response = developerConnectClient.FetchReadWriteToken(gitRepositoryLink);

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
FetchReadWriteTokenRequest request = new FetchReadWriteTokenRequest
{
    GitRepositoryLinkAsGitRepositoryLinkName = GitRepositoryLinkName.FromProjectLocationConnectionGitRepositoryLink("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[GIT_REPOSITORY_LINK]"),
};
// Make the request
FetchReadWriteTokenResponse response = await developerConnectClient.FetchReadWriteTokenAsync(request);

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
FetchReadWriteTokenRequest request = new FetchReadWriteTokenRequest
{
    GitRepositoryLinkAsGitRepositoryLinkName = GitRepositoryLinkName.FromProjectLocationConnectionGitRepositoryLink("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[GIT_REPOSITORY_LINK]"),
};
// Make the request
FetchReadWriteTokenResponse response = await developerConnectClient.FetchReadWriteTokenAsync(request);

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
GitRepositoryLinkName gitRepositoryLink = GitRepositoryLinkName.FromProjectLocationConnectionGitRepositoryLink("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[GIT_REPOSITORY_LINK]");
// Make the request
FetchReadWriteTokenResponse response = await developerConnectClient.FetchReadWriteTokenAsync(gitRepositoryLink);

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
GitRepositoryLinkName gitRepositoryLink = GitRepositoryLinkName.FromProjectLocationConnectionGitRepositoryLink("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[GIT_REPOSITORY_LINK]");
// Make the request
FetchReadWriteTokenResponse response = await developerConnectClient.FetchReadWriteTokenAsync(gitRepositoryLink);

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
string gitRepositoryLink = "projects/[PROJECT]/locations/[LOCATION]/connections/[CONNECTION]/gitRepositoryLinks/[GIT_REPOSITORY_LINK]";
// Make the request
FetchReadWriteTokenResponse response = await developerConnectClient.FetchReadWriteTokenAsync(gitRepositoryLink);

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
string gitRepositoryLink = "projects/[PROJECT]/locations/[LOCATION]/connections/[CONNECTION]/gitRepositoryLinks/[GIT_REPOSITORY_LINK]";
// Make the request
FetchReadWriteTokenResponse response = await developerConnectClient.FetchReadWriteTokenAsync(gitRepositoryLink);

// Create client
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
ConnectionName name = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]");
// Make the request
Connection response = developerConnectClient.GetConnection(name);

// Create client
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
GetConnectionRequest request = new GetConnectionRequest
{
    ConnectionName = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]"),
};
// Make the request
Connection response = developerConnectClient.GetConnection(request);

// Create client
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connections/[CONNECTION]";
// Make the request
Connection response = developerConnectClient.GetConnection(name);

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
ConnectionName name = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]");
// Make the request
Connection response = await developerConnectClient.GetConnectionAsync(name);

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
ConnectionName name = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]");
// Make the request
Connection response = await developerConnectClient.GetConnectionAsync(name);

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
GetConnectionRequest request = new GetConnectionRequest
{
    ConnectionName = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]"),
};
// Make the request
Connection response = await developerConnectClient.GetConnectionAsync(request);

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
GetConnectionRequest request = new GetConnectionRequest
{
    ConnectionName = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]"),
};
// Make the request
Connection response = await developerConnectClient.GetConnectionAsync(request);

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connections/[CONNECTION]";
// Make the request
Connection response = await developerConnectClient.GetConnectionAsync(name);

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connections/[CONNECTION]";
// Make the request
Connection response = await developerConnectClient.GetConnectionAsync(name);

// Create client
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
GetGitRepositoryLinkRequest request = new GetGitRepositoryLinkRequest
{
    GitRepositoryLinkName = GitRepositoryLinkName.FromProjectLocationConnectionGitRepositoryLink("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[GIT_REPOSITORY_LINK]"),
};
// Make the request
GitRepositoryLink response = developerConnectClient.GetGitRepositoryLink(request);

// Create client
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
GitRepositoryLinkName name = GitRepositoryLinkName.FromProjectLocationConnectionGitRepositoryLink("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[GIT_REPOSITORY_LINK]");
// Make the request
GitRepositoryLink response = developerConnectClient.GetGitRepositoryLink(name);

// Create client
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connections/[CONNECTION]/gitRepositoryLinks/[GIT_REPOSITORY_LINK]";
// Make the request
GitRepositoryLink response = developerConnectClient.GetGitRepositoryLink(name);

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
GetGitRepositoryLinkRequest request = new GetGitRepositoryLinkRequest
{
    GitRepositoryLinkName = GitRepositoryLinkName.FromProjectLocationConnectionGitRepositoryLink("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[GIT_REPOSITORY_LINK]"),
};
// Make the request
GitRepositoryLink response = await developerConnectClient.GetGitRepositoryLinkAsync(request);

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
GetGitRepositoryLinkRequest request = new GetGitRepositoryLinkRequest
{
    GitRepositoryLinkName = GitRepositoryLinkName.FromProjectLocationConnectionGitRepositoryLink("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[GIT_REPOSITORY_LINK]"),
};
// Make the request
GitRepositoryLink response = await developerConnectClient.GetGitRepositoryLinkAsync(request);

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
GitRepositoryLinkName name = GitRepositoryLinkName.FromProjectLocationConnectionGitRepositoryLink("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[GIT_REPOSITORY_LINK]");
// Make the request
GitRepositoryLink response = await developerConnectClient.GetGitRepositoryLinkAsync(name);

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
GitRepositoryLinkName name = GitRepositoryLinkName.FromProjectLocationConnectionGitRepositoryLink("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[GIT_REPOSITORY_LINK]");
// Make the request
GitRepositoryLink response = await developerConnectClient.GetGitRepositoryLinkAsync(name);

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connections/[CONNECTION]/gitRepositoryLinks/[GIT_REPOSITORY_LINK]";
// Make the request
GitRepositoryLink response = await developerConnectClient.GetGitRepositoryLinkAsync(name);

// Create client
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connections/[CONNECTION]/gitRepositoryLinks/[GIT_REPOSITORY_LINK]";
// Make the request
GitRepositoryLink response = await developerConnectClient.GetGitRepositoryLinkAsync(name);

// Create client
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListConnectionsResponse, Connection> response = developerConnectClient.ListConnections(parent);

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

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

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

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

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

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Connection 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((ListConnectionsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Connection 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<Connection> 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 (Connection 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
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
ConnectionName parent = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]");
// Make the request
PagedEnumerable<ListGitRepositoryLinksResponse, GitRepositoryLink> response = developerConnectClient.ListGitRepositoryLinks(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (GitRepositoryLink 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 (ListGitRepositoryLinksResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (GitRepositoryLink 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<GitRepositoryLink> 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 (GitRepositoryLink 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
DeveloperConnectClient developerConnectClient = DeveloperConnectClient.Create();
// Initialize request argument(s)
ListGitRepositoryLinksRequest request = new ListGitRepositoryLinksRequest
{
    ParentAsConnectionName = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedEnumerable<ListGitRepositoryLinksResponse, GitRepositoryLink> response = developerConnectClient.ListGitRepositoryLinks(request);

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

// Iterate over all response items, lazily performing RPCs as required
foreach (GitRepositoryLink 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 (ListGitRepositoryLinksResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (GitRepositoryLink 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<GitRepositoryLink> 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 (GitRepositoryLink 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
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
ConnectionName parent = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]");
// Make the request
PagedAsyncEnumerable<ListGitRepositoryLinksResponse, GitRepositoryLink> response = developerConnectClient.ListGitRepositoryLinksAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((GitRepositoryLink 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((ListGitRepositoryLinksResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (GitRepositoryLink 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<GitRepositoryLink> 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 (GitRepositoryLink 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
DeveloperConnectClient developerConnectClient = await DeveloperConnectClient.CreateAsync();
// Initialize request argument(s)
ListGitRepositoryLinksRequest request = new ListGitRepositoryLinksRequest
{
    ParentAsConnectionName = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedAsyncEnumerable<ListGitRepositoryLinksResponse, GitRepositoryLink> response = developerConnectClient.ListGitRepositoryLinksAsync(request);

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

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