Distributed Cloud Edge Network v1 API - Class EdgeNetworkClient (1.0.0)

// Create client
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
CreateInterconnectAttachmentRequest request = new CreateInterconnectAttachmentRequest
{
    ParentAsZoneName = ZoneName.FromProjectLocationZone("[PROJECT]", "[LOCATION]", "[ZONE]"),
    InterconnectAttachmentId = "",
    InterconnectAttachment = new InterconnectAttachment(),
    RequestId = "",
};
// Make the request
Operation<InterconnectAttachment, OperationMetadata> response = edgeNetworkClient.CreateInterconnectAttachment(request);

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

// Create client
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
ZoneName parent = ZoneName.FromProjectLocationZone("[PROJECT]", "[LOCATION]", "[ZONE]");
InterconnectAttachment interconnectAttachment = new InterconnectAttachment();
string interconnectAttachmentId = "";
// Make the request
Operation<InterconnectAttachment, OperationMetadata> response = edgeNetworkClient.CreateInterconnectAttachment(parent, interconnectAttachment, interconnectAttachmentId);

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

// Create client
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]";
InterconnectAttachment interconnectAttachment = new InterconnectAttachment();
string interconnectAttachmentId = "";
// Make the request
Operation<InterconnectAttachment, OperationMetadata> response = edgeNetworkClient.CreateInterconnectAttachment(parent, interconnectAttachment, interconnectAttachmentId);

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

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
CreateInterconnectAttachmentRequest request = new CreateInterconnectAttachmentRequest
{
    ParentAsZoneName = ZoneName.FromProjectLocationZone("[PROJECT]", "[LOCATION]", "[ZONE]"),
    InterconnectAttachmentId = "",
    InterconnectAttachment = new InterconnectAttachment(),
    RequestId = "",
};
// Make the request
Operation<InterconnectAttachment, OperationMetadata> response = await edgeNetworkClient.CreateInterconnectAttachmentAsync(request);

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

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
CreateInterconnectAttachmentRequest request = new CreateInterconnectAttachmentRequest
{
    ParentAsZoneName = ZoneName.FromProjectLocationZone("[PROJECT]", "[LOCATION]", "[ZONE]"),
    InterconnectAttachmentId = "",
    InterconnectAttachment = new InterconnectAttachment(),
    RequestId = "",
};
// Make the request
Operation<InterconnectAttachment, OperationMetadata> response = await edgeNetworkClient.CreateInterconnectAttachmentAsync(request);

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

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
ZoneName parent = ZoneName.FromProjectLocationZone("[PROJECT]", "[LOCATION]", "[ZONE]");
InterconnectAttachment interconnectAttachment = new InterconnectAttachment();
string interconnectAttachmentId = "";
// Make the request
Operation<InterconnectAttachment, OperationMetadata> response = await edgeNetworkClient.CreateInterconnectAttachmentAsync(parent, interconnectAttachment, interconnectAttachmentId);

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

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
ZoneName parent = ZoneName.FromProjectLocationZone("[PROJECT]", "[LOCATION]", "[ZONE]");
InterconnectAttachment interconnectAttachment = new InterconnectAttachment();
string interconnectAttachmentId = "";
// Make the request
Operation<InterconnectAttachment, OperationMetadata> response = await edgeNetworkClient.CreateInterconnectAttachmentAsync(parent, interconnectAttachment, interconnectAttachmentId);

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

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]";
InterconnectAttachment interconnectAttachment = new InterconnectAttachment();
string interconnectAttachmentId = "";
// Make the request
Operation<InterconnectAttachment, OperationMetadata> response = await edgeNetworkClient.CreateInterconnectAttachmentAsync(parent, interconnectAttachment, interconnectAttachmentId);

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

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]";
InterconnectAttachment interconnectAttachment = new InterconnectAttachment();
string interconnectAttachmentId = "";
// Make the request
Operation<InterconnectAttachment, OperationMetadata> response = await edgeNetworkClient.CreateInterconnectAttachmentAsync(parent, interconnectAttachment, interconnectAttachmentId);

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

// Create client
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
CreateNetworkRequest request = new CreateNetworkRequest
{
    ParentAsZoneName = ZoneName.FromProjectLocationZone("[PROJECT]", "[LOCATION]", "[ZONE]"),
    NetworkId = "",
    Network = new Network(),
    RequestId = "",
};
// Make the request
Operation<Network, OperationMetadata> response = edgeNetworkClient.CreateNetwork(request);

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

// Create client
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
ZoneName parent = ZoneName.FromProjectLocationZone("[PROJECT]", "[LOCATION]", "[ZONE]");
Network network = new Network();
string networkId = "";
// Make the request
Operation<Network, OperationMetadata> response = edgeNetworkClient.CreateNetwork(parent, network, networkId);

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

// Create client
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]";
Network network = new Network();
string networkId = "";
// Make the request
Operation<Network, OperationMetadata> response = edgeNetworkClient.CreateNetwork(parent, network, networkId);

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

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
CreateNetworkRequest request = new CreateNetworkRequest
{
    ParentAsZoneName = ZoneName.FromProjectLocationZone("[PROJECT]", "[LOCATION]", "[ZONE]"),
    NetworkId = "",
    Network = new Network(),
    RequestId = "",
};
// Make the request
Operation<Network, OperationMetadata> response = await edgeNetworkClient.CreateNetworkAsync(request);

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

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
CreateNetworkRequest request = new CreateNetworkRequest
{
    ParentAsZoneName = ZoneName.FromProjectLocationZone("[PROJECT]", "[LOCATION]", "[ZONE]"),
    NetworkId = "",
    Network = new Network(),
    RequestId = "",
};
// Make the request
Operation<Network, OperationMetadata> response = await edgeNetworkClient.CreateNetworkAsync(request);

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

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
ZoneName parent = ZoneName.FromProjectLocationZone("[PROJECT]", "[LOCATION]", "[ZONE]");
Network network = new Network();
string networkId = "";
// Make the request
Operation<Network, OperationMetadata> response = await edgeNetworkClient.CreateNetworkAsync(parent, network, networkId);

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

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
ZoneName parent = ZoneName.FromProjectLocationZone("[PROJECT]", "[LOCATION]", "[ZONE]");
Network network = new Network();
string networkId = "";
// Make the request
Operation<Network, OperationMetadata> response = await edgeNetworkClient.CreateNetworkAsync(parent, network, networkId);

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

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]";
Network network = new Network();
string networkId = "";
// Make the request
Operation<Network, OperationMetadata> response = await edgeNetworkClient.CreateNetworkAsync(parent, network, networkId);

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

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]";
Network network = new Network();
string networkId = "";
// Make the request
Operation<Network, OperationMetadata> response = await edgeNetworkClient.CreateNetworkAsync(parent, network, networkId);

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

// Create client
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
CreateRouterRequest request = new CreateRouterRequest
{
    ParentAsZoneName = ZoneName.FromProjectLocationZone("[PROJECT]", "[LOCATION]", "[ZONE]"),
    RouterId = "",
    Router = new Router(),
    RequestId = "",
};
// Make the request
Operation<Router, OperationMetadata> response = edgeNetworkClient.CreateRouter(request);

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

// Create client
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
ZoneName parent = ZoneName.FromProjectLocationZone("[PROJECT]", "[LOCATION]", "[ZONE]");
Router router = new Router();
string routerId = "";
// Make the request
Operation<Router, OperationMetadata> response = edgeNetworkClient.CreateRouter(parent, router, routerId);

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

// Create client
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]";
Router router = new Router();
string routerId = "";
// Make the request
Operation<Router, OperationMetadata> response = edgeNetworkClient.CreateRouter(parent, router, routerId);

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

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
CreateRouterRequest request = new CreateRouterRequest
{
    ParentAsZoneName = ZoneName.FromProjectLocationZone("[PROJECT]", "[LOCATION]", "[ZONE]"),
    RouterId = "",
    Router = new Router(),
    RequestId = "",
};
// Make the request
Operation<Router, OperationMetadata> response = await edgeNetworkClient.CreateRouterAsync(request);

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

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
CreateRouterRequest request = new CreateRouterRequest
{
    ParentAsZoneName = ZoneName.FromProjectLocationZone("[PROJECT]", "[LOCATION]", "[ZONE]"),
    RouterId = "",
    Router = new Router(),
    RequestId = "",
};
// Make the request
Operation<Router, OperationMetadata> response = await edgeNetworkClient.CreateRouterAsync(request);

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

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
ZoneName parent = ZoneName.FromProjectLocationZone("[PROJECT]", "[LOCATION]", "[ZONE]");
Router router = new Router();
string routerId = "";
// Make the request
Operation<Router, OperationMetadata> response = await edgeNetworkClient.CreateRouterAsync(parent, router, routerId);

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

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
ZoneName parent = ZoneName.FromProjectLocationZone("[PROJECT]", "[LOCATION]", "[ZONE]");
Router router = new Router();
string routerId = "";
// Make the request
Operation<Router, OperationMetadata> response = await edgeNetworkClient.CreateRouterAsync(parent, router, routerId);

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

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]";
Router router = new Router();
string routerId = "";
// Make the request
Operation<Router, OperationMetadata> response = await edgeNetworkClient.CreateRouterAsync(parent, router, routerId);

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

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]";
Router router = new Router();
string routerId = "";
// Make the request
Operation<Router, OperationMetadata> response = await edgeNetworkClient.CreateRouterAsync(parent, router, routerId);

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

// Create client
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
CreateSubnetRequest request = new CreateSubnetRequest
{
    ParentAsZoneName = ZoneName.FromProjectLocationZone("[PROJECT]", "[LOCATION]", "[ZONE]"),
    SubnetId = "",
    Subnet = new Subnet(),
    RequestId = "",
};
// Make the request
Operation<Subnet, OperationMetadata> response = edgeNetworkClient.CreateSubnet(request);

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

// Create client
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
ZoneName parent = ZoneName.FromProjectLocationZone("[PROJECT]", "[LOCATION]", "[ZONE]");
Subnet subnet = new Subnet();
string subnetId = "";
// Make the request
Operation<Subnet, OperationMetadata> response = edgeNetworkClient.CreateSubnet(parent, subnet, subnetId);

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

// Create client
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]";
Subnet subnet = new Subnet();
string subnetId = "";
// Make the request
Operation<Subnet, OperationMetadata> response = edgeNetworkClient.CreateSubnet(parent, subnet, subnetId);

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

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
CreateSubnetRequest request = new CreateSubnetRequest
{
    ParentAsZoneName = ZoneName.FromProjectLocationZone("[PROJECT]", "[LOCATION]", "[ZONE]"),
    SubnetId = "",
    Subnet = new Subnet(),
    RequestId = "",
};
// Make the request
Operation<Subnet, OperationMetadata> response = await edgeNetworkClient.CreateSubnetAsync(request);

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

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
CreateSubnetRequest request = new CreateSubnetRequest
{
    ParentAsZoneName = ZoneName.FromProjectLocationZone("[PROJECT]", "[LOCATION]", "[ZONE]"),
    SubnetId = "",
    Subnet = new Subnet(),
    RequestId = "",
};
// Make the request
Operation<Subnet, OperationMetadata> response = await edgeNetworkClient.CreateSubnetAsync(request);

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

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
ZoneName parent = ZoneName.FromProjectLocationZone("[PROJECT]", "[LOCATION]", "[ZONE]");
Subnet subnet = new Subnet();
string subnetId = "";
// Make the request
Operation<Subnet, OperationMetadata> response = await edgeNetworkClient.CreateSubnetAsync(parent, subnet, subnetId);

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

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
ZoneName parent = ZoneName.FromProjectLocationZone("[PROJECT]", "[LOCATION]", "[ZONE]");
Subnet subnet = new Subnet();
string subnetId = "";
// Make the request
Operation<Subnet, OperationMetadata> response = await edgeNetworkClient.CreateSubnetAsync(parent, subnet, subnetId);

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

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]";
Subnet subnet = new Subnet();
string subnetId = "";
// Make the request
Operation<Subnet, OperationMetadata> response = await edgeNetworkClient.CreateSubnetAsync(parent, subnet, subnetId);

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

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]";
Subnet subnet = new Subnet();
string subnetId = "";
// Make the request
Operation<Subnet, OperationMetadata> response = await edgeNetworkClient.CreateSubnetAsync(parent, subnet, subnetId);

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

// Create client
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
DeleteInterconnectAttachmentRequest request = new DeleteInterconnectAttachmentRequest
{
    InterconnectAttachmentName = InterconnectAttachmentName.FromProjectLocationZoneInterconnectAttachment("[PROJECT]", "[LOCATION]", "[ZONE]", "[INTERCONNECT_ATTACHMENT]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = edgeNetworkClient.DeleteInterconnectAttachment(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 = edgeNetworkClient.PollOnceDeleteInterconnectAttachment(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
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
InterconnectAttachmentName name = InterconnectAttachmentName.FromProjectLocationZoneInterconnectAttachment("[PROJECT]", "[LOCATION]", "[ZONE]", "[INTERCONNECT_ATTACHMENT]");
// Make the request
Operation<Empty, OperationMetadata> response = edgeNetworkClient.DeleteInterconnectAttachment(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 = edgeNetworkClient.PollOnceDeleteInterconnectAttachment(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
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]/interconnectAttachments/[INTERCONNECT_ATTACHMENT]";
// Make the request
Operation<Empty, OperationMetadata> response = edgeNetworkClient.DeleteInterconnectAttachment(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 = edgeNetworkClient.PollOnceDeleteInterconnectAttachment(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
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
DeleteInterconnectAttachmentRequest request = new DeleteInterconnectAttachmentRequest
{
    InterconnectAttachmentName = InterconnectAttachmentName.FromProjectLocationZoneInterconnectAttachment("[PROJECT]", "[LOCATION]", "[ZONE]", "[INTERCONNECT_ATTACHMENT]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await edgeNetworkClient.DeleteInterconnectAttachmentAsync(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 edgeNetworkClient.PollOnceDeleteInterconnectAttachmentAsync(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
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
DeleteInterconnectAttachmentRequest request = new DeleteInterconnectAttachmentRequest
{
    InterconnectAttachmentName = InterconnectAttachmentName.FromProjectLocationZoneInterconnectAttachment("[PROJECT]", "[LOCATION]", "[ZONE]", "[INTERCONNECT_ATTACHMENT]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await edgeNetworkClient.DeleteInterconnectAttachmentAsync(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 edgeNetworkClient.PollOnceDeleteInterconnectAttachmentAsync(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
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
InterconnectAttachmentName name = InterconnectAttachmentName.FromProjectLocationZoneInterconnectAttachment("[PROJECT]", "[LOCATION]", "[ZONE]", "[INTERCONNECT_ATTACHMENT]");
// Make the request
Operation<Empty, OperationMetadata> response = await edgeNetworkClient.DeleteInterconnectAttachmentAsync(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 edgeNetworkClient.PollOnceDeleteInterconnectAttachmentAsync(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
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
InterconnectAttachmentName name = InterconnectAttachmentName.FromProjectLocationZoneInterconnectAttachment("[PROJECT]", "[LOCATION]", "[ZONE]", "[INTERCONNECT_ATTACHMENT]");
// Make the request
Operation<Empty, OperationMetadata> response = await edgeNetworkClient.DeleteInterconnectAttachmentAsync(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 edgeNetworkClient.PollOnceDeleteInterconnectAttachmentAsync(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
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]/interconnectAttachments/[INTERCONNECT_ATTACHMENT]";
// Make the request
Operation<Empty, OperationMetadata> response = await edgeNetworkClient.DeleteInterconnectAttachmentAsync(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 edgeNetworkClient.PollOnceDeleteInterconnectAttachmentAsync(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
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]/interconnectAttachments/[INTERCONNECT_ATTACHMENT]";
// Make the request
Operation<Empty, OperationMetadata> response = await edgeNetworkClient.DeleteInterconnectAttachmentAsync(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 edgeNetworkClient.PollOnceDeleteInterconnectAttachmentAsync(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
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
DeleteNetworkRequest request = new DeleteNetworkRequest
{
    NetworkName = NetworkName.FromProjectLocationZoneNetwork("[PROJECT]", "[LOCATION]", "[ZONE]", "[NETWORK]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = edgeNetworkClient.DeleteNetwork(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 = edgeNetworkClient.PollOnceDeleteNetwork(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
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
NetworkName name = NetworkName.FromProjectLocationZoneNetwork("[PROJECT]", "[LOCATION]", "[ZONE]", "[NETWORK]");
// Make the request
Operation<Empty, OperationMetadata> response = edgeNetworkClient.DeleteNetwork(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 = edgeNetworkClient.PollOnceDeleteNetwork(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
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]/networks/[NETWORK]";
// Make the request
Operation<Empty, OperationMetadata> response = edgeNetworkClient.DeleteNetwork(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 = edgeNetworkClient.PollOnceDeleteNetwork(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
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
DeleteNetworkRequest request = new DeleteNetworkRequest
{
    NetworkName = NetworkName.FromProjectLocationZoneNetwork("[PROJECT]", "[LOCATION]", "[ZONE]", "[NETWORK]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await edgeNetworkClient.DeleteNetworkAsync(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 edgeNetworkClient.PollOnceDeleteNetworkAsync(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
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
DeleteNetworkRequest request = new DeleteNetworkRequest
{
    NetworkName = NetworkName.FromProjectLocationZoneNetwork("[PROJECT]", "[LOCATION]", "[ZONE]", "[NETWORK]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await edgeNetworkClient.DeleteNetworkAsync(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 edgeNetworkClient.PollOnceDeleteNetworkAsync(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
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
NetworkName name = NetworkName.FromProjectLocationZoneNetwork("[PROJECT]", "[LOCATION]", "[ZONE]", "[NETWORK]");
// Make the request
Operation<Empty, OperationMetadata> response = await edgeNetworkClient.DeleteNetworkAsync(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 edgeNetworkClient.PollOnceDeleteNetworkAsync(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
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
NetworkName name = NetworkName.FromProjectLocationZoneNetwork("[PROJECT]", "[LOCATION]", "[ZONE]", "[NETWORK]");
// Make the request
Operation<Empty, OperationMetadata> response = await edgeNetworkClient.DeleteNetworkAsync(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 edgeNetworkClient.PollOnceDeleteNetworkAsync(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
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]/networks/[NETWORK]";
// Make the request
Operation<Empty, OperationMetadata> response = await edgeNetworkClient.DeleteNetworkAsync(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 edgeNetworkClient.PollOnceDeleteNetworkAsync(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
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]/networks/[NETWORK]";
// Make the request
Operation<Empty, OperationMetadata> response = await edgeNetworkClient.DeleteNetworkAsync(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 edgeNetworkClient.PollOnceDeleteNetworkAsync(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
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
DeleteRouterRequest request = new DeleteRouterRequest
{
    RouterName = RouterName.FromProjectLocationZoneRouter("[PROJECT]", "[LOCATION]", "[ZONE]", "[ROUTER]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = edgeNetworkClient.DeleteRouter(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 = edgeNetworkClient.PollOnceDeleteRouter(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
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
RouterName name = RouterName.FromProjectLocationZoneRouter("[PROJECT]", "[LOCATION]", "[ZONE]", "[ROUTER]");
// Make the request
Operation<Empty, OperationMetadata> response = edgeNetworkClient.DeleteRouter(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 = edgeNetworkClient.PollOnceDeleteRouter(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
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]/routers/[ROUTER]";
// Make the request
Operation<Empty, OperationMetadata> response = edgeNetworkClient.DeleteRouter(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 = edgeNetworkClient.PollOnceDeleteRouter(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
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
DeleteRouterRequest request = new DeleteRouterRequest
{
    RouterName = RouterName.FromProjectLocationZoneRouter("[PROJECT]", "[LOCATION]", "[ZONE]", "[ROUTER]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await edgeNetworkClient.DeleteRouterAsync(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 edgeNetworkClient.PollOnceDeleteRouterAsync(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
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
DeleteRouterRequest request = new DeleteRouterRequest
{
    RouterName = RouterName.FromProjectLocationZoneRouter("[PROJECT]", "[LOCATION]", "[ZONE]", "[ROUTER]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await edgeNetworkClient.DeleteRouterAsync(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 edgeNetworkClient.PollOnceDeleteRouterAsync(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
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
RouterName name = RouterName.FromProjectLocationZoneRouter("[PROJECT]", "[LOCATION]", "[ZONE]", "[ROUTER]");
// Make the request
Operation<Empty, OperationMetadata> response = await edgeNetworkClient.DeleteRouterAsync(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 edgeNetworkClient.PollOnceDeleteRouterAsync(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
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
RouterName name = RouterName.FromProjectLocationZoneRouter("[PROJECT]", "[LOCATION]", "[ZONE]", "[ROUTER]");
// Make the request
Operation<Empty, OperationMetadata> response = await edgeNetworkClient.DeleteRouterAsync(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 edgeNetworkClient.PollOnceDeleteRouterAsync(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
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]/routers/[ROUTER]";
// Make the request
Operation<Empty, OperationMetadata> response = await edgeNetworkClient.DeleteRouterAsync(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 edgeNetworkClient.PollOnceDeleteRouterAsync(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
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]/routers/[ROUTER]";
// Make the request
Operation<Empty, OperationMetadata> response = await edgeNetworkClient.DeleteRouterAsync(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 edgeNetworkClient.PollOnceDeleteRouterAsync(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
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
DeleteSubnetRequest request = new DeleteSubnetRequest
{
    SubnetName = SubnetName.FromProjectLocationZoneSubnet("[PROJECT]", "[LOCATION]", "[ZONE]", "[SUBNET]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = edgeNetworkClient.DeleteSubnet(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 = edgeNetworkClient.PollOnceDeleteSubnet(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
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
SubnetName name = SubnetName.FromProjectLocationZoneSubnet("[PROJECT]", "[LOCATION]", "[ZONE]", "[SUBNET]");
// Make the request
Operation<Empty, OperationMetadata> response = edgeNetworkClient.DeleteSubnet(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 = edgeNetworkClient.PollOnceDeleteSubnet(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
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]/subnets/[SUBNET]";
// Make the request
Operation<Empty, OperationMetadata> response = edgeNetworkClient.DeleteSubnet(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 = edgeNetworkClient.PollOnceDeleteSubnet(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
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
DeleteSubnetRequest request = new DeleteSubnetRequest
{
    SubnetName = SubnetName.FromProjectLocationZoneSubnet("[PROJECT]", "[LOCATION]", "[ZONE]", "[SUBNET]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await edgeNetworkClient.DeleteSubnetAsync(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 edgeNetworkClient.PollOnceDeleteSubnetAsync(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
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
DeleteSubnetRequest request = new DeleteSubnetRequest
{
    SubnetName = SubnetName.FromProjectLocationZoneSubnet("[PROJECT]", "[LOCATION]", "[ZONE]", "[SUBNET]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await edgeNetworkClient.DeleteSubnetAsync(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 edgeNetworkClient.PollOnceDeleteSubnetAsync(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
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
SubnetName name = SubnetName.FromProjectLocationZoneSubnet("[PROJECT]", "[LOCATION]", "[ZONE]", "[SUBNET]");
// Make the request
Operation<Empty, OperationMetadata> response = await edgeNetworkClient.DeleteSubnetAsync(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 edgeNetworkClient.PollOnceDeleteSubnetAsync(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
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
SubnetName name = SubnetName.FromProjectLocationZoneSubnet("[PROJECT]", "[LOCATION]", "[ZONE]", "[SUBNET]");
// Make the request
Operation<Empty, OperationMetadata> response = await edgeNetworkClient.DeleteSubnetAsync(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 edgeNetworkClient.PollOnceDeleteSubnetAsync(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
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]/subnets/[SUBNET]";
// Make the request
Operation<Empty, OperationMetadata> response = await edgeNetworkClient.DeleteSubnetAsync(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 edgeNetworkClient.PollOnceDeleteSubnetAsync(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
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]/subnets/[SUBNET]";
// Make the request
Operation<Empty, OperationMetadata> response = await edgeNetworkClient.DeleteSubnetAsync(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 edgeNetworkClient.PollOnceDeleteSubnetAsync(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
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
DiagnoseInterconnectRequest request = new DiagnoseInterconnectRequest
{
    InterconnectName = InterconnectName.FromProjectLocationZoneInterconnect("[PROJECT]", "[LOCATION]", "[ZONE]", "[INTERCONNECT]"),
};
// Make the request
DiagnoseInterconnectResponse response = edgeNetworkClient.DiagnoseInterconnect(request);

// Create client
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
InterconnectName name = InterconnectName.FromProjectLocationZoneInterconnect("[PROJECT]", "[LOCATION]", "[ZONE]", "[INTERCONNECT]");
// Make the request
DiagnoseInterconnectResponse response = edgeNetworkClient.DiagnoseInterconnect(name);

// Create client
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]/interconnects/[INTERCONNECT]";
// Make the request
DiagnoseInterconnectResponse response = edgeNetworkClient.DiagnoseInterconnect(name);

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
DiagnoseInterconnectRequest request = new DiagnoseInterconnectRequest
{
    InterconnectName = InterconnectName.FromProjectLocationZoneInterconnect("[PROJECT]", "[LOCATION]", "[ZONE]", "[INTERCONNECT]"),
};
// Make the request
DiagnoseInterconnectResponse response = await edgeNetworkClient.DiagnoseInterconnectAsync(request);

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
DiagnoseInterconnectRequest request = new DiagnoseInterconnectRequest
{
    InterconnectName = InterconnectName.FromProjectLocationZoneInterconnect("[PROJECT]", "[LOCATION]", "[ZONE]", "[INTERCONNECT]"),
};
// Make the request
DiagnoseInterconnectResponse response = await edgeNetworkClient.DiagnoseInterconnectAsync(request);

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
InterconnectName name = InterconnectName.FromProjectLocationZoneInterconnect("[PROJECT]", "[LOCATION]", "[ZONE]", "[INTERCONNECT]");
// Make the request
DiagnoseInterconnectResponse response = await edgeNetworkClient.DiagnoseInterconnectAsync(name);

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
InterconnectName name = InterconnectName.FromProjectLocationZoneInterconnect("[PROJECT]", "[LOCATION]", "[ZONE]", "[INTERCONNECT]");
// Make the request
DiagnoseInterconnectResponse response = await edgeNetworkClient.DiagnoseInterconnectAsync(name);

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]/interconnects/[INTERCONNECT]";
// Make the request
DiagnoseInterconnectResponse response = await edgeNetworkClient.DiagnoseInterconnectAsync(name);

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]/interconnects/[INTERCONNECT]";
// Make the request
DiagnoseInterconnectResponse response = await edgeNetworkClient.DiagnoseInterconnectAsync(name);

// Create client
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
DiagnoseNetworkRequest request = new DiagnoseNetworkRequest
{
    NetworkName = NetworkName.FromProjectLocationZoneNetwork("[PROJECT]", "[LOCATION]", "[ZONE]", "[NETWORK]"),
};
// Make the request
DiagnoseNetworkResponse response = edgeNetworkClient.DiagnoseNetwork(request);

// Create client
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
NetworkName name = NetworkName.FromProjectLocationZoneNetwork("[PROJECT]", "[LOCATION]", "[ZONE]", "[NETWORK]");
// Make the request
DiagnoseNetworkResponse response = edgeNetworkClient.DiagnoseNetwork(name);

// Create client
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]/networks/[NETWORK]";
// Make the request
DiagnoseNetworkResponse response = edgeNetworkClient.DiagnoseNetwork(name);

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
DiagnoseNetworkRequest request = new DiagnoseNetworkRequest
{
    NetworkName = NetworkName.FromProjectLocationZoneNetwork("[PROJECT]", "[LOCATION]", "[ZONE]", "[NETWORK]"),
};
// Make the request
DiagnoseNetworkResponse response = await edgeNetworkClient.DiagnoseNetworkAsync(request);

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
DiagnoseNetworkRequest request = new DiagnoseNetworkRequest
{
    NetworkName = NetworkName.FromProjectLocationZoneNetwork("[PROJECT]", "[LOCATION]", "[ZONE]", "[NETWORK]"),
};
// Make the request
DiagnoseNetworkResponse response = await edgeNetworkClient.DiagnoseNetworkAsync(request);

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
NetworkName name = NetworkName.FromProjectLocationZoneNetwork("[PROJECT]", "[LOCATION]", "[ZONE]", "[NETWORK]");
// Make the request
DiagnoseNetworkResponse response = await edgeNetworkClient.DiagnoseNetworkAsync(name);

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
NetworkName name = NetworkName.FromProjectLocationZoneNetwork("[PROJECT]", "[LOCATION]", "[ZONE]", "[NETWORK]");
// Make the request
DiagnoseNetworkResponse response = await edgeNetworkClient.DiagnoseNetworkAsync(name);

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]/networks/[NETWORK]";
// Make the request
DiagnoseNetworkResponse response = await edgeNetworkClient.DiagnoseNetworkAsync(name);

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]/networks/[NETWORK]";
// Make the request
DiagnoseNetworkResponse response = await edgeNetworkClient.DiagnoseNetworkAsync(name);

// Create client
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
DiagnoseRouterRequest request = new DiagnoseRouterRequest
{
    RouterName = RouterName.FromProjectLocationZoneRouter("[PROJECT]", "[LOCATION]", "[ZONE]", "[ROUTER]"),
};
// Make the request
DiagnoseRouterResponse response = edgeNetworkClient.DiagnoseRouter(request);

// Create client
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
RouterName name = RouterName.FromProjectLocationZoneRouter("[PROJECT]", "[LOCATION]", "[ZONE]", "[ROUTER]");
// Make the request
DiagnoseRouterResponse response = edgeNetworkClient.DiagnoseRouter(name);

// Create client
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]/routers/[ROUTER]";
// Make the request
DiagnoseRouterResponse response = edgeNetworkClient.DiagnoseRouter(name);

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
DiagnoseRouterRequest request = new DiagnoseRouterRequest
{
    RouterName = RouterName.FromProjectLocationZoneRouter("[PROJECT]", "[LOCATION]", "[ZONE]", "[ROUTER]"),
};
// Make the request
DiagnoseRouterResponse response = await edgeNetworkClient.DiagnoseRouterAsync(request);

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
DiagnoseRouterRequest request = new DiagnoseRouterRequest
{
    RouterName = RouterName.FromProjectLocationZoneRouter("[PROJECT]", "[LOCATION]", "[ZONE]", "[ROUTER]"),
};
// Make the request
DiagnoseRouterResponse response = await edgeNetworkClient.DiagnoseRouterAsync(request);

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
RouterName name = RouterName.FromProjectLocationZoneRouter("[PROJECT]", "[LOCATION]", "[ZONE]", "[ROUTER]");
// Make the request
DiagnoseRouterResponse response = await edgeNetworkClient.DiagnoseRouterAsync(name);

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
RouterName name = RouterName.FromProjectLocationZoneRouter("[PROJECT]", "[LOCATION]", "[ZONE]", "[ROUTER]");
// Make the request
DiagnoseRouterResponse response = await edgeNetworkClient.DiagnoseRouterAsync(name);

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]/routers/[ROUTER]";
// Make the request
DiagnoseRouterResponse response = await edgeNetworkClient.DiagnoseRouterAsync(name);

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]/routers/[ROUTER]";
// Make the request
DiagnoseRouterResponse response = await edgeNetworkClient.DiagnoseRouterAsync(name);

// Create client
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
GetInterconnectRequest request = new GetInterconnectRequest
{
    InterconnectName = InterconnectName.FromProjectLocationZoneInterconnect("[PROJECT]", "[LOCATION]", "[ZONE]", "[INTERCONNECT]"),
};
// Make the request
Interconnect response = edgeNetworkClient.GetInterconnect(request);

// Create client
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
InterconnectName name = InterconnectName.FromProjectLocationZoneInterconnect("[PROJECT]", "[LOCATION]", "[ZONE]", "[INTERCONNECT]");
// Make the request
Interconnect response = edgeNetworkClient.GetInterconnect(name);

// Create client
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]/interconnects/[INTERCONNECT]";
// Make the request
Interconnect response = edgeNetworkClient.GetInterconnect(name);

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
GetInterconnectRequest request = new GetInterconnectRequest
{
    InterconnectName = InterconnectName.FromProjectLocationZoneInterconnect("[PROJECT]", "[LOCATION]", "[ZONE]", "[INTERCONNECT]"),
};
// Make the request
Interconnect response = await edgeNetworkClient.GetInterconnectAsync(request);

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
GetInterconnectRequest request = new GetInterconnectRequest
{
    InterconnectName = InterconnectName.FromProjectLocationZoneInterconnect("[PROJECT]", "[LOCATION]", "[ZONE]", "[INTERCONNECT]"),
};
// Make the request
Interconnect response = await edgeNetworkClient.GetInterconnectAsync(request);

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
InterconnectName name = InterconnectName.FromProjectLocationZoneInterconnect("[PROJECT]", "[LOCATION]", "[ZONE]", "[INTERCONNECT]");
// Make the request
Interconnect response = await edgeNetworkClient.GetInterconnectAsync(name);

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
InterconnectName name = InterconnectName.FromProjectLocationZoneInterconnect("[PROJECT]", "[LOCATION]", "[ZONE]", "[INTERCONNECT]");
// Make the request
Interconnect response = await edgeNetworkClient.GetInterconnectAsync(name);

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]/interconnects/[INTERCONNECT]";
// Make the request
Interconnect response = await edgeNetworkClient.GetInterconnectAsync(name);

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]/interconnects/[INTERCONNECT]";
// Make the request
Interconnect response = await edgeNetworkClient.GetInterconnectAsync(name);

// Create client
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
GetInterconnectAttachmentRequest request = new GetInterconnectAttachmentRequest
{
    InterconnectAttachmentName = InterconnectAttachmentName.FromProjectLocationZoneInterconnectAttachment("[PROJECT]", "[LOCATION]", "[ZONE]", "[INTERCONNECT_ATTACHMENT]"),
};
// Make the request
InterconnectAttachment response = edgeNetworkClient.GetInterconnectAttachment(request);

// Create client
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
InterconnectAttachmentName name = InterconnectAttachmentName.FromProjectLocationZoneInterconnectAttachment("[PROJECT]", "[LOCATION]", "[ZONE]", "[INTERCONNECT_ATTACHMENT]");
// Make the request
InterconnectAttachment response = edgeNetworkClient.GetInterconnectAttachment(name);

// Create client
EdgeNetworkClient edgeNetworkClient = EdgeNetworkClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]/interconnectAttachments/[INTERCONNECT_ATTACHMENT]";
// Make the request
InterconnectAttachment response = edgeNetworkClient.GetInterconnectAttachment(name);

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
GetInterconnectAttachmentRequest request = new GetInterconnectAttachmentRequest
{
    InterconnectAttachmentName = InterconnectAttachmentName.FromProjectLocationZoneInterconnectAttachment("[PROJECT]", "[LOCATION]", "[ZONE]", "[INTERCONNECT_ATTACHMENT]"),
};
// Make the request
InterconnectAttachment response = await edgeNetworkClient.GetInterconnectAttachmentAsync(request);

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
GetInterconnectAttachmentRequest request = new GetInterconnectAttachmentRequest
{
    InterconnectAttachmentName = InterconnectAttachmentName.FromProjectLocationZoneInterconnectAttachment("[PROJECT]", "[LOCATION]", "[ZONE]", "[INTERCONNECT_ATTACHMENT]"),
};
// Make the request
InterconnectAttachment response = await edgeNetworkClient.GetInterconnectAttachmentAsync(request);

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
InterconnectAttachmentName name = InterconnectAttachmentName.FromProjectLocationZoneInterconnectAttachment("[PROJECT]", "[LOCATION]", "[ZONE]", "[INTERCONNECT_ATTACHMENT]");
// Make the request
InterconnectAttachment response = await edgeNetworkClient.GetInterconnectAttachmentAsync(name);

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
InterconnectAttachmentName name = InterconnectAttachmentName.FromProjectLocationZoneInterconnectAttachment("[PROJECT]", "[LOCATION]", "[ZONE]", "[INTERCONNECT_ATTACHMENT]");
// Make the request
InterconnectAttachment response = await edgeNetworkClient.GetInterconnectAttachmentAsync(name);

// Create client
EdgeNetworkClient edgeNetworkClient = await EdgeNetworkClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]/interconnectAttachments/[INTERCONNECT_ATTACHMENT]";
// Make the request
InterconnectAttachment response = await edgeNetworkClient.GetInterconnectAttachmentAsync(name);