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

public abstract class EdgeNetworkClient

Namespace

Assembly

Google.Cloud.EdgeNetwork.V1.dll

Remarks

Properties

CreateInterconnectAttachmentOperationsClient

public virtual OperationsClient CreateInterconnectAttachmentOperationsClient { get; }

CreateNetworkOperationsClient

public virtual OperationsClient CreateNetworkOperationsClient { get; }

CreateRouterOperationsClient

public virtual OperationsClient CreateRouterOperationsClient { get; }

CreateSubnetOperationsClient

public virtual OperationsClient CreateSubnetOperationsClient { get; }

DefaultEndpoint

public static string DefaultEndpoint { get; }

DefaultScopes

public static IReadOnlyList<string> DefaultScopes { get; }

DeleteInterconnectAttachmentOperationsClient

public virtual OperationsClient DeleteInterconnectAttachmentOperationsClient { get; }

DeleteNetworkOperationsClient

public virtual OperationsClient DeleteNetworkOperationsClient { get; }

DeleteRouterOperationsClient

public virtual OperationsClient DeleteRouterOperationsClient { get; }

DeleteSubnetOperationsClient

public virtual OperationsClient DeleteSubnetOperationsClient { get; }

GrpcClient

public virtual EdgeNetwork.EdgeNetworkClient GrpcClient { get; }

LocationsClient

public virtual LocationsClient LocationsClient { get; }

ServiceMetadata

public static ServiceMetadata ServiceMetadata { get; }

UpdateRouterOperationsClient

public virtual OperationsClient UpdateRouterOperationsClient { get; }

UpdateSubnetOperationsClient

public virtual OperationsClient UpdateSubnetOperationsClient { get; }

Methods

Create()

public static EdgeNetworkClient Create()

CreateAsync(CancellationToken)

public static Task<EdgeNetworkClient> CreateAsync(CancellationToken cancellationToken = default)

CreateInterconnectAttachment(CreateInterconnectAttachmentRequest, CallSettings)

public virtual Operation<InterconnectAttachment, OperationMetadata> CreateInterconnectAttachment(CreateInterconnectAttachmentRequest request, CallSettings callSettings = null)

// 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;
}

CreateInterconnectAttachment(ZoneName, InterconnectAttachment, string, CallSettings)

public virtual Operation<InterconnectAttachment, OperationMetadata> CreateInterconnectAttachment(ZoneName parent, InterconnectAttachment interconnectAttachment, string interconnectAttachmentId, CallSettings callSettings = null)

// 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;
}

CreateInterconnectAttachment(string, InterconnectAttachment, string, CallSettings)

public virtual Operation<InterconnectAttachment, OperationMetadata> CreateInterconnectAttachment(string parent, InterconnectAttachment interconnectAttachment, string interconnectAttachmentId, CallSettings callSettings = null)

// 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;
}

CreateInterconnectAttachmentAsync(CreateInterconnectAttachmentRequest, CallSettings)

public virtual Task<Operation<InterconnectAttachment, OperationMetadata>> CreateInterconnectAttachmentAsync(CreateInterconnectAttachmentRequest request, CallSettings callSettings = null)

// 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;
}

CreateInterconnectAttachmentAsync(CreateInterconnectAttachmentRequest, CancellationToken)

public virtual Task<Operation<InterconnectAttachment, OperationMetadata>> CreateInterconnectAttachmentAsync(CreateInterconnectAttachmentRequest request, CancellationToken cancellationToken)

// 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;
}

CreateInterconnectAttachmentAsync(ZoneName, InterconnectAttachment, string, CallSettings)

public virtual Task<Operation<InterconnectAttachment, OperationMetadata>> CreateInterconnectAttachmentAsync(ZoneName parent, InterconnectAttachment interconnectAttachment, string interconnectAttachmentId, CallSettings callSettings = null)

// 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;
}

CreateInterconnectAttachmentAsync(ZoneName, InterconnectAttachment, string, CancellationToken)

public virtual Task<Operation<InterconnectAttachment, OperationMetadata>> CreateInterconnectAttachmentAsync(ZoneName parent, InterconnectAttachment interconnectAttachment, string interconnectAttachmentId, CancellationToken cancellationToken)

// 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;
}

CreateInterconnectAttachmentAsync(string, InterconnectAttachment, string, CallSettings)

public virtual Task<Operation<InterconnectAttachment, OperationMetadata>> CreateInterconnectAttachmentAsync(string parent, InterconnectAttachment interconnectAttachment, string interconnectAttachmentId, CallSettings callSettings = null)

// 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;
}

CreateInterconnectAttachmentAsync(string, InterconnectAttachment, string, CancellationToken)

public virtual Task<Operation<InterconnectAttachment, OperationMetadata>> CreateInterconnectAttachmentAsync(string parent, InterconnectAttachment interconnectAttachment, string interconnectAttachmentId, CancellationToken cancellationToken)

// 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;
}

CreateNetwork(CreateNetworkRequest, CallSettings)

public virtual Operation<Network, OperationMetadata> CreateNetwork(CreateNetworkRequest request, CallSettings callSettings = null)

// 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;
}

CreateNetwork(ZoneName, Network, string, CallSettings)

public virtual Operation<Network, OperationMetadata> CreateNetwork(ZoneName parent, Network network, string networkId, CallSettings callSettings = null)

// 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;
}

CreateNetwork(string, Network, string, CallSettings)

public virtual Operation<Network, OperationMetadata> CreateNetwork(string parent, Network network, string networkId, CallSettings callSettings = null)

// 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;
}

CreateNetworkAsync(CreateNetworkRequest, CallSettings)

public virtual Task<Operation<Network, OperationMetadata>> CreateNetworkAsync(CreateNetworkRequest request, CallSettings callSettings = null)

// 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;
}

CreateNetworkAsync(CreateNetworkRequest, CancellationToken)

public virtual Task<Operation<Network, OperationMetadata>> CreateNetworkAsync(CreateNetworkRequest request, CancellationToken cancellationToken)

// 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;
}

CreateNetworkAsync(ZoneName, Network, string, CallSettings)

public virtual Task<Operation<Network, OperationMetadata>> CreateNetworkAsync(ZoneName parent, Network network, string networkId, CallSettings callSettings = null)

// 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;
}

CreateNetworkAsync(ZoneName, Network, string, CancellationToken)

public virtual Task<Operation<Network, OperationMetadata>> CreateNetworkAsync(ZoneName parent, Network network, string networkId, CancellationToken cancellationToken)

// 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;
}

CreateNetworkAsync(string, Network, string, CallSettings)

public virtual Task<Operation<Network, OperationMetadata>> CreateNetworkAsync(string parent, Network network, string networkId, CallSettings callSettings = null)

// 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;
}

CreateNetworkAsync(string, Network, string, CancellationToken)

public virtual Task<Operation<Network, OperationMetadata>> CreateNetworkAsync(string parent, Network network, string networkId, CancellationToken cancellationToken)

// 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;
}

CreateRouter(CreateRouterRequest, CallSettings)

public virtual Operation<Router, OperationMetadata> CreateRouter(CreateRouterRequest request, CallSettings callSettings = null)

// 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;
}

CreateRouter(ZoneName, Router, string, CallSettings)

public virtual Operation<Router, OperationMetadata> CreateRouter(ZoneName parent, Router router, string routerId, CallSettings callSettings = null)

// 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;
}

CreateRouter(string, Router, string, CallSettings)

public virtual Operation<Router, OperationMetadata> CreateRouter(string parent, Router router, string routerId, CallSettings callSettings = null)

// 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;
}

CreateRouterAsync(CreateRouterRequest, CallSettings)

public virtual Task<Operation<Router, OperationMetadata>> CreateRouterAsync(CreateRouterRequest request, CallSettings callSettings = null)

// 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;
}

CreateRouterAsync(CreateRouterRequest, CancellationToken)

public virtual Task<Operation<Router, OperationMetadata>> CreateRouterAsync(CreateRouterRequest request, CancellationToken cancellationToken)

// 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;
}

CreateRouterAsync(ZoneName, Router, string, CallSettings)

public virtual Task<Operation<Router, OperationMetadata>> CreateRouterAsync(ZoneName parent, Router router, string routerId, CallSettings callSettings = null)

// 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;
}

CreateRouterAsync(ZoneName, Router, string, CancellationToken)

public virtual Task<Operation<Router, OperationMetadata>> CreateRouterAsync(ZoneName parent, Router router, string routerId, CancellationToken cancellationToken)

// 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;
}

CreateRouterAsync(string, Router, string, CallSettings)

public virtual Task<Operation<Router, OperationMetadata>> CreateRouterAsync(string parent, Router router, string routerId, CallSettings callSettings = null)

// 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;
}

CreateRouterAsync(string, Router, string, CancellationToken)

public virtual Task<Operation<Router, OperationMetadata>> CreateRouterAsync(string parent, Router router, string routerId, CancellationToken cancellationToken)

// 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;
}

CreateSubnet(CreateSubnetRequest, CallSettings)

public virtual Operation<Subnet, OperationMetadata> CreateSubnet(CreateSubnetRequest request, CallSettings callSettings = null)

// 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;
}

CreateSubnet(ZoneName, Subnet, string, CallSettings)

public virtual Operation<Subnet, OperationMetadata> CreateSubnet(ZoneName parent, Subnet subnet, string subnetId, CallSettings callSettings = null)

// 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;
}

CreateSubnet(string, Subnet, string, CallSettings)

public virtual Operation<Subnet, OperationMetadata> CreateSubnet(string parent, Subnet subnet, string subnetId, CallSettings callSettings = null)

// 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;
}

CreateSubnetAsync(CreateSubnetRequest, CallSettings)

public virtual Task<Operation<Subnet, OperationMetadata>> CreateSubnetAsync(CreateSubnetRequest request, CallSettings callSettings = null)

// 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;
}

CreateSubnetAsync(CreateSubnetRequest, CancellationToken)

public virtual Task<Operation<Subnet, OperationMetadata>> CreateSubnetAsync(CreateSubnetRequest request, CancellationToken cancellationToken)

// 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;
}

CreateSubnetAsync(ZoneName, Subnet, string, CallSettings)

public virtual Task<Operation<Subnet, OperationMetadata>> CreateSubnetAsync(ZoneName parent, Subnet subnet, string subnetId, CallSettings callSettings = null)

// 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;
}

CreateSubnetAsync(ZoneName, Subnet, string, CancellationToken)

public virtual Task<Operation<Subnet, OperationMetadata>> CreateSubnetAsync(ZoneName parent, Subnet subnet, string subnetId, CancellationToken cancellationToken)

// 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;
}

CreateSubnetAsync(string, Subnet, string, CallSettings)

public virtual Task<Operation<Subnet, OperationMetadata>> CreateSubnetAsync(string parent, Subnet subnet, string subnetId, CallSettings callSettings = null)

// 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;
}

CreateSubnetAsync(string, Subnet, string, CancellationToken)

public virtual Task<Operation<Subnet, OperationMetadata>> CreateSubnetAsync(string parent, Subnet subnet, string subnetId, CancellationToken cancellationToken)

// 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;
}

DeleteInterconnectAttachment(DeleteInterconnectAttachmentRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteInterconnectAttachment(DeleteInterconnectAttachmentRequest request, CallSettings callSettings = null)

// 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;
}

DeleteInterconnectAttachment(InterconnectAttachmentName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteInterconnectAttachment(InterconnectAttachmentName name, CallSettings callSettings = null)

// 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;
}

DeleteInterconnectAttachment(string, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteInterconnectAttachment(string name, CallSettings callSettings = null)

// 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;
}

DeleteInterconnectAttachmentAsync(DeleteInterconnectAttachmentRequest, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteInterconnectAttachmentAsync(DeleteInterconnectAttachmentRequest request, CallSettings callSettings = null)

// 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;
}

DeleteInterconnectAttachmentAsync(DeleteInterconnectAttachmentRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteInterconnectAttachmentAsync(DeleteInterconnectAttachmentRequest request, CancellationToken cancellationToken)

// 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;
}

DeleteInterconnectAttachmentAsync(InterconnectAttachmentName, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteInterconnectAttachmentAsync(InterconnectAttachmentName name, CallSettings callSettings = null)

// 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;
}

DeleteInterconnectAttachmentAsync(InterconnectAttachmentName, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteInterconnectAttachmentAsync(InterconnectAttachmentName name, CancellationToken cancellationToken)

// 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;
}

DeleteInterconnectAttachmentAsync(string, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteInterconnectAttachmentAsync(string name, CallSettings callSettings = null)

// 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;
}

DeleteInterconnectAttachmentAsync(string, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteInterconnectAttachmentAsync(string name, CancellationToken cancellationToken)

// 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;
}

DeleteNetwork(DeleteNetworkRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteNetwork(DeleteNetworkRequest request, CallSettings callSettings = null)

// 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;
}

DeleteNetwork(NetworkName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteNetwork(NetworkName name, CallSettings callSettings = null)

// 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;
}

DeleteNetwork(string, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteNetwork(string name, CallSettings callSettings = null)

// 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;
}

DeleteNetworkAsync(DeleteNetworkRequest, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteNetworkAsync(DeleteNetworkRequest request, CallSettings callSettings = null)

// 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;
}

DeleteNetworkAsync(DeleteNetworkRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteNetworkAsync(DeleteNetworkRequest request, CancellationToken cancellationToken)

// 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;
}

DeleteNetworkAsync(NetworkName, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteNetworkAsync(NetworkName name, CallSettings callSettings = null)

// 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;
}

DeleteNetworkAsync(NetworkName, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteNetworkAsync(NetworkName name, CancellationToken cancellationToken)

// 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;
}

DeleteNetworkAsync(string, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteNetworkAsync(string name, CallSettings callSettings = null)

// 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;
}

DeleteNetworkAsync(string, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteNetworkAsync(string name, CancellationToken cancellationToken)

// 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;
}

DeleteRouter(DeleteRouterRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteRouter(DeleteRouterRequest request, CallSettings callSettings = null)

// 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;
}

DeleteRouter(RouterName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteRouter(RouterName name, CallSettings callSettings = null)

// 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;
}

DeleteRouter(string, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteRouter(string name, CallSettings callSettings = null)

// 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;
}

DeleteRouterAsync(DeleteRouterRequest, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteRouterAsync(DeleteRouterRequest request, CallSettings callSettings = null)

// 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;
}

DeleteRouterAsync(DeleteRouterRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteRouterAsync(DeleteRouterRequest request, CancellationToken cancellationToken)

// 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;
}

DeleteRouterAsync(RouterName, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteRouterAsync(RouterName name, CallSettings callSettings = null)

// 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;
}

DeleteRouterAsync(RouterName, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteRouterAsync(RouterName name, CancellationToken cancellationToken)

// 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;
}

DeleteRouterAsync(string, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteRouterAsync(string name, CallSettings callSettings = null)

// 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;
}

DeleteRouterAsync(string, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteRouterAsync(string name, CancellationToken cancellationToken)

// 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;
}

DeleteSubnet(DeleteSubnetRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteSubnet(DeleteSubnetRequest request, CallSettings callSettings = null)

// 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;
}

DeleteSubnet(SubnetName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteSubnet(SubnetName name, CallSettings callSettings = null)

// 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;
}

DeleteSubnet(string, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteSubnet(string name, CallSettings callSettings = null)

// 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;
}

DeleteSubnetAsync(DeleteSubnetRequest, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteSubnetAsync(DeleteSubnetRequest request, CallSettings callSettings = null)

// 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;
}

DeleteSubnetAsync(DeleteSubnetRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteSubnetAsync(DeleteSubnetRequest request, CancellationToken cancellationToken)

// 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;
}

DeleteSubnetAsync(SubnetName, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteSubnetAsync(SubnetName name, CallSettings callSettings = null)

// 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;
}

DeleteSubnetAsync(SubnetName, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteSubnetAsync(SubnetName name, CancellationToken cancellationToken)

// 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;
}

DeleteSubnetAsync(string, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteSubnetAsync(string name, CallSettings callSettings = null)

// 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;
}

DeleteSubnetAsync(string, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteSubnetAsync(string name, CancellationToken cancellationToken)

// 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;
}

DiagnoseInterconnect(DiagnoseInterconnectRequest, CallSettings)

public virtual DiagnoseInterconnectResponse DiagnoseInterconnect(DiagnoseInterconnectRequest request, CallSettings callSettings = null)

// 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);

DiagnoseInterconnect(InterconnectName, CallSettings)

public virtual DiagnoseInterconnectResponse DiagnoseInterconnect(InterconnectName name, CallSettings callSettings = null)

// 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);

DiagnoseInterconnect(string, CallSettings)

public virtual DiagnoseInterconnectResponse DiagnoseInterconnect(string name, CallSettings callSettings = null)

// 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);

DiagnoseInterconnectAsync(DiagnoseInterconnectRequest, CallSettings)

public virtual Task<DiagnoseInterconnectResponse> DiagnoseInterconnectAsync(DiagnoseInterconnectRequest request, CallSettings callSettings = null)

// 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);

DiagnoseInterconnectAsync(DiagnoseInterconnectRequest, CancellationToken)

public virtual Task<DiagnoseInterconnectResponse> DiagnoseInterconnectAsync(DiagnoseInterconnectRequest request, CancellationToken cancellationToken)

// 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);

DiagnoseInterconnectAsync(InterconnectName, CallSettings)

public virtual Task<DiagnoseInterconnectResponse> DiagnoseInterconnectAsync(InterconnectName name, CallSettings callSettings = null)

// 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);

DiagnoseInterconnectAsync(InterconnectName, CancellationToken)

public virtual Task<DiagnoseInterconnectResponse> DiagnoseInterconnectAsync(InterconnectName name, CancellationToken cancellationToken)

// 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);

DiagnoseInterconnectAsync(string, CallSettings)

public virtual Task<DiagnoseInterconnectResponse> DiagnoseInterconnectAsync(string name, CallSettings callSettings = null)

// 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);

DiagnoseInterconnectAsync(string, CancellationToken)

public virtual Task<DiagnoseInterconnectResponse> DiagnoseInterconnectAsync(string name, CancellationToken cancellationToken)

// 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);

DiagnoseNetwork(DiagnoseNetworkRequest, CallSettings)

public virtual DiagnoseNetworkResponse DiagnoseNetwork(DiagnoseNetworkRequest request, CallSettings callSettings = null)

// 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);

DiagnoseNetwork(NetworkName, CallSettings)

public virtual DiagnoseNetworkResponse DiagnoseNetwork(NetworkName name, CallSettings callSettings = null)

// 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);

DiagnoseNetwork(string, CallSettings)

public virtual DiagnoseNetworkResponse DiagnoseNetwork(string name, CallSettings callSettings = null)

// 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);

DiagnoseNetworkAsync(DiagnoseNetworkRequest, CallSettings)

public virtual Task<DiagnoseNetworkResponse> DiagnoseNetworkAsync(DiagnoseNetworkRequest request, CallSettings callSettings = null)

// 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);

DiagnoseNetworkAsync(DiagnoseNetworkRequest, CancellationToken)

public virtual Task<DiagnoseNetworkResponse> DiagnoseNetworkAsync(DiagnoseNetworkRequest request, CancellationToken cancellationToken)

// 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);

DiagnoseNetworkAsync(NetworkName, CallSettings)

public virtual Task<DiagnoseNetworkResponse> DiagnoseNetworkAsync(NetworkName name, CallSettings callSettings = null)

// 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);

DiagnoseNetworkAsync(NetworkName, CancellationToken)

public virtual Task<DiagnoseNetworkResponse> DiagnoseNetworkAsync(NetworkName name, CancellationToken cancellationToken)

// 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);

DiagnoseNetworkAsync(string, CallSettings)

public virtual Task<DiagnoseNetworkResponse> DiagnoseNetworkAsync(string name, CallSettings callSettings = null)

// 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);

DiagnoseNetworkAsync(string, CancellationToken)

public virtual Task<DiagnoseNetworkResponse> DiagnoseNetworkAsync(string name, CancellationToken cancellationToken)

// 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);

DiagnoseRouter(DiagnoseRouterRequest, CallSettings)

public virtual DiagnoseRouterResponse DiagnoseRouter(DiagnoseRouterRequest request, CallSettings callSettings = null)

// 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);

DiagnoseRouter(RouterName, CallSettings)

public virtual DiagnoseRouterResponse DiagnoseRouter(RouterName name, CallSettings callSettings = null)

// 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);

DiagnoseRouter(string, CallSettings)

public virtual DiagnoseRouterResponse DiagnoseRouter(string name, CallSettings callSettings = null)

// 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);

DiagnoseRouterAsync(DiagnoseRouterRequest, CallSettings)

public virtual Task<DiagnoseRouterResponse> DiagnoseRouterAsync(DiagnoseRouterRequest request, CallSettings callSettings = null)

// 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);

DiagnoseRouterAsync(DiagnoseRouterRequest, CancellationToken)

public virtual Task<DiagnoseRouterResponse> DiagnoseRouterAsync(DiagnoseRouterRequest request, CancellationToken cancellationToken)

// 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);

DiagnoseRouterAsync(RouterName, CallSettings)

public virtual Task<DiagnoseRouterResponse> DiagnoseRouterAsync(RouterName name, CallSettings callSettings = null)

// 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);

DiagnoseRouterAsync(RouterName, CancellationToken)

public virtual Task<DiagnoseRouterResponse> DiagnoseRouterAsync(RouterName name, CancellationToken cancellationToken)

// 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);

DiagnoseRouterAsync(string, CallSettings)

public virtual Task<DiagnoseRouterResponse> DiagnoseRouterAsync(string name, CallSettings callSettings = null)

// 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);

DiagnoseRouterAsync(string, CancellationToken)

public virtual Task<DiagnoseRouterResponse> DiagnoseRouterAsync(string name, CancellationToken cancellationToken)

// 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);

GetInterconnect(GetInterconnectRequest, CallSettings)

public virtual Interconnect GetInterconnect(GetInterconnectRequest request, CallSettings callSettings = null)

// 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);

GetInterconnect(InterconnectName, CallSettings)

public virtual Interconnect GetInterconnect(InterconnectName name, CallSettings callSettings = null)

// 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);

GetInterconnect(string, CallSettings)

public virtual Interconnect GetInterconnect(string name, CallSettings callSettings = null)

// 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);

GetInterconnectAsync(GetInterconnectRequest, CallSettings)

public virtual Task<Interconnect> GetInterconnectAsync(GetInterconnectRequest request, CallSettings callSettings = null)

// 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);

GetInterconnectAsync(GetInterconnectRequest, CancellationToken)

public virtual Task<Interconnect> GetInterconnectAsync(GetInterconnectRequest request, CancellationToken cancellationToken)

// 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);

GetInterconnectAsync(InterconnectName, CallSettings)

public virtual Task<Interconnect> GetInterconnectAsync(InterconnectName name, CallSettings callSettings = null)

// 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);

GetInterconnectAsync(InterconnectName, CancellationToken)

public virtual Task<Interconnect> GetInterconnectAsync(InterconnectName name, CancellationToken cancellationToken)

// 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);

GetInterconnectAsync(string, CallSettings)

public virtual Task<Interconnect> GetInterconnectAsync(string name, CallSettings callSettings = null)

// 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);

GetInterconnectAsync(string, CancellationToken)

public virtual Task<Interconnect> GetInterconnectAsync(string name, CancellationToken cancellationToken)

// 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);

GetInterconnectAttachment(GetInterconnectAttachmentRequest, CallSettings)

public virtual InterconnectAttachment GetInterconnectAttachment(GetInterconnectAttachmentRequest request, CallSettings callSettings = null)

// 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);

GetInterconnectAttachment(InterconnectAttachmentName, CallSettings)

public virtual InterconnectAttachment GetInterconnectAttachment(InterconnectAttachmentName name, CallSettings callSettings = null)

// 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);

GetInterconnectAttachment(string, CallSettings)

public virtual InterconnectAttachment GetInterconnectAttachment(string name, CallSettings callSettings = null)

// 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);

GetInterconnectAttachmentAsync(GetInterconnectAttachmentRequest, CallSettings)

public virtual Task<InterconnectAttachment> GetInterconnectAttachmentAsync(GetInterconnectAttachmentRequest request, CallSettings callSettings = null)

// 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);

GetInterconnectAttachmentAsync(GetInterconnectAttachmentRequest, CancellationToken)

public virtual Task<InterconnectAttachment> GetInterconnectAttachmentAsync(GetInterconnectAttachmentRequest request, CancellationToken cancellationToken)

// 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);

GetInterconnectAttachmentAsync(InterconnectAttachmentName, CallSettings)

public virtual Task<InterconnectAttachment> GetInterconnectAttachmentAsync(InterconnectAttachmentName name, CallSettings callSettings = null)

// 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);

GetInterconnectAttachmentAsync(InterconnectAttachmentName, CancellationToken)

public virtual Task<InterconnectAttachment> GetInterconnectAttachmentAsync(InterconnectAttachmentName name, CancellationToken cancellationToken)

// 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);

GetInterconnectAttachmentAsync(string, CallSettings)

public virtual Task<InterconnectAttachment> GetInterconnectAttachmentAsync(string name, CallSettings callSettings = null)

// 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);

GetInterconnectAttachmentAsync(string, CancellationToken)

public virtual Task<InterconnectAttachment> GetInterconnectAttachmentAsync(string name, CancellationToken cancellationToken)

// 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);

GetNetwork(GetNetworkRequest, CallSettings)

public virtual Network GetNetwork(GetNetworkRequest request, CallSettings callSettings = null)

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

GetNetwork(NetworkName, CallSettings)

public virtual Network GetNetwork(NetworkName name, CallSettings callSettings = null)

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

GetNetwork(string, CallSettings)

public virtual Network GetNetwork(string name, CallSettings callSettings = null)

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

GetNetworkAsync(GetNetworkRequest, CallSettings)

public virtual Task<Network> GetNetworkAsync(GetNetworkRequest request, CallSettings callSettings = null)

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

GetNetworkAsync(GetNetworkRequest, CancellationToken)

public virtual Task<Network> GetNetworkAsync(GetNetworkRequest request, CancellationToken cancellationToken)

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

GetNetworkAsync(NetworkName, CallSettings)

public virtual Task<Network> GetNetworkAsync(NetworkName name, CallSettings callSettings = null)

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

GetNetworkAsync(NetworkName, CancellationToken)

public virtual Task<Network> GetNetworkAsync(NetworkName name, CancellationToken cancellationToken)

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

GetNetworkAsync(string, CallSettings)

public virtual Task<Network> GetNetworkAsync(string name, CallSettings callSettings = null)

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

GetNetworkAsync(string, CancellationToken)

public virtual Task<Network> GetNetworkAsync(string name, CancellationToken cancellationToken)

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

GetRouter(GetRouterRequest, CallSettings)

public virtual Router GetRouter(GetRouterRequest request, CallSettings callSettings = null)