Compute Engine v1 API - Class AcceleratorTypesClient (3.0.0)

public abstract class AcceleratorTypesClient

Namespace

Assembly

Google.Cloud.Compute.V1.dll

Remarks

Properties

DefaultEndpoint

public static string DefaultEndpoint { get; }

DefaultScopes

public static IReadOnlyList<string> DefaultScopes { get; }

GrpcClient

public virtual AcceleratorTypes.AcceleratorTypesClient GrpcClient { get; }

ServiceMetadata

public static ServiceMetadata ServiceMetadata { get; }

Methods

AggregatedList(AggregatedListAcceleratorTypesRequest, CallSettings)

public virtual PagedEnumerable<AcceleratorTypeAggregatedList, KeyValuePair<string, AcceleratorTypesScopedList>> AggregatedList(AggregatedListAcceleratorTypesRequest request, CallSettings callSettings = null)

// Create client
AcceleratorTypesClient acceleratorTypesClient = AcceleratorTypesClient.Create();
// Initialize request argument(s)
AggregatedListAcceleratorTypesRequest request = new AggregatedListAcceleratorTypesRequest
{
    OrderBy = "",
    Project = "",
    ServiceProjectNumber = 0L,
    Filter = "",
    IncludeAllScopes = false,
    ReturnPartialSuccess = false,
};
// Make the request
PagedEnumerable<AcceleratorTypeAggregatedList, KeyValuePair<string, AcceleratorTypesScopedList>> response = acceleratorTypesClient.AggregatedList(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (KeyValuePair<string, AcceleratorTypesScopedList> item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (AcceleratorTypeAggregatedList page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (KeyValuePair<string, AcceleratorTypesScopedList> item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<KeyValuePair<string, AcceleratorTypesScopedList>> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (KeyValuePair<string, AcceleratorTypesScopedList> item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

AggregatedList(string, string, int?, CallSettings)

public virtual PagedEnumerable<AcceleratorTypeAggregatedList, KeyValuePair<string, AcceleratorTypesScopedList>> AggregatedList(string project, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
AcceleratorTypesClient acceleratorTypesClient = AcceleratorTypesClient.Create();
// Initialize request argument(s)
string project = "";
// Make the request
PagedEnumerable<AcceleratorTypeAggregatedList, KeyValuePair<string, AcceleratorTypesScopedList>> response = acceleratorTypesClient.AggregatedList(project);

// Iterate over all response items, lazily performing RPCs as required
foreach (KeyValuePair<string, AcceleratorTypesScopedList> item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (AcceleratorTypeAggregatedList page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (KeyValuePair<string, AcceleratorTypesScopedList> item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<KeyValuePair<string, AcceleratorTypesScopedList>> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (KeyValuePair<string, AcceleratorTypesScopedList> item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

AggregatedListAsync(AggregatedListAcceleratorTypesRequest, CallSettings)

public virtual PagedAsyncEnumerable<AcceleratorTypeAggregatedList, KeyValuePair<string, AcceleratorTypesScopedList>> AggregatedListAsync(AggregatedListAcceleratorTypesRequest request, CallSettings callSettings = null)

// Create client
AcceleratorTypesClient acceleratorTypesClient = await AcceleratorTypesClient.CreateAsync();
// Initialize request argument(s)
AggregatedListAcceleratorTypesRequest request = new AggregatedListAcceleratorTypesRequest
{
    OrderBy = "",
    Project = "",
    ServiceProjectNumber = 0L,
    Filter = "",
    IncludeAllScopes = false,
    ReturnPartialSuccess = false,
};
// Make the request
PagedAsyncEnumerable<AcceleratorTypeAggregatedList, KeyValuePair<string, AcceleratorTypesScopedList>> response = acceleratorTypesClient.AggregatedListAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((KeyValuePair<string, AcceleratorTypesScopedList> item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((AcceleratorTypeAggregatedList page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (KeyValuePair<string, AcceleratorTypesScopedList> item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<KeyValuePair<string, AcceleratorTypesScopedList>> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (KeyValuePair<string, AcceleratorTypesScopedList> item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

AggregatedListAsync(string, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<AcceleratorTypeAggregatedList, KeyValuePair<string, AcceleratorTypesScopedList>> AggregatedListAsync(string project, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
AcceleratorTypesClient acceleratorTypesClient = await AcceleratorTypesClient.CreateAsync();
// Initialize request argument(s)
string project = "";
// Make the request
PagedAsyncEnumerable<AcceleratorTypeAggregatedList, KeyValuePair<string, AcceleratorTypesScopedList>> response = acceleratorTypesClient.AggregatedListAsync(project);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((KeyValuePair<string, AcceleratorTypesScopedList> item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((AcceleratorTypeAggregatedList page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (KeyValuePair<string, AcceleratorTypesScopedList> item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<KeyValuePair<string, AcceleratorTypesScopedList>> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (KeyValuePair<string, AcceleratorTypesScopedList> item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

Create()

public static AcceleratorTypesClient Create()

CreateAsync(CancellationToken)

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

Get(GetAcceleratorTypeRequest, CallSettings)

public virtual AcceleratorType Get(GetAcceleratorTypeRequest request, CallSettings callSettings = null)

// Create client
AcceleratorTypesClient acceleratorTypesClient = AcceleratorTypesClient.Create();
// Initialize request argument(s)
GetAcceleratorTypeRequest request = new GetAcceleratorTypeRequest
{
    Zone = "",
    AcceleratorType = "",
    Project = "",
};
// Make the request
AcceleratorType response = acceleratorTypesClient.Get(request);

Get(string, string, string, CallSettings)

public virtual AcceleratorType Get(string project, string zone, string acceleratorType, CallSettings callSettings = null)

// Create client
AcceleratorTypesClient acceleratorTypesClient = AcceleratorTypesClient.Create();
// Initialize request argument(s)
string project = "";
string zone = "";
string acceleratorType = "";
// Make the request
AcceleratorType response = acceleratorTypesClient.Get(project, zone, acceleratorType);

GetAsync(GetAcceleratorTypeRequest, CallSettings)

public virtual Task<AcceleratorType> GetAsync(GetAcceleratorTypeRequest request, CallSettings callSettings = null)

// Create client
AcceleratorTypesClient acceleratorTypesClient = await AcceleratorTypesClient.CreateAsync();
// Initialize request argument(s)
GetAcceleratorTypeRequest request = new GetAcceleratorTypeRequest
{
    Zone = "",
    AcceleratorType = "",
    Project = "",
};
// Make the request
AcceleratorType response = await acceleratorTypesClient.GetAsync(request);

GetAsync(GetAcceleratorTypeRequest, CancellationToken)

public virtual Task<AcceleratorType> GetAsync(GetAcceleratorTypeRequest request, CancellationToken cancellationToken)

// Create client
AcceleratorTypesClient acceleratorTypesClient = await AcceleratorTypesClient.CreateAsync();
// Initialize request argument(s)
GetAcceleratorTypeRequest request = new GetAcceleratorTypeRequest
{
    Zone = "",
    AcceleratorType = "",
    Project = "",
};
// Make the request
AcceleratorType response = await acceleratorTypesClient.GetAsync(request);

GetAsync(string, string, string, CallSettings)

public virtual Task<AcceleratorType> GetAsync(string project, string zone, string acceleratorType, CallSettings callSettings = null)

// Create client
AcceleratorTypesClient acceleratorTypesClient = await AcceleratorTypesClient.CreateAsync();
// Initialize request argument(s)
string project = "";
string zone = "";
string acceleratorType = "";
// Make the request
AcceleratorType response = await acceleratorTypesClient.GetAsync(project, zone, acceleratorType);

GetAsync(string, string, string, CancellationToken)

public virtual Task<AcceleratorType> GetAsync(string project, string zone, string acceleratorType, CancellationToken cancellationToken)

// Create client
AcceleratorTypesClient acceleratorTypesClient = await AcceleratorTypesClient.CreateAsync();
// Initialize request argument(s)
string project = "";
string zone = "";
string acceleratorType = "";
// Make the request
AcceleratorType response = await acceleratorTypesClient.GetAsync(project, zone, acceleratorType);

List(ListAcceleratorTypesRequest, CallSettings)

public virtual PagedEnumerable<AcceleratorTypeList, AcceleratorType> List(ListAcceleratorTypesRequest request, CallSettings callSettings = null)

// Create client
AcceleratorTypesClient acceleratorTypesClient = AcceleratorTypesClient.Create();
// Initialize request argument(s)
ListAcceleratorTypesRequest request = new ListAcceleratorTypesRequest
{
    Zone = "",
    OrderBy = "",
    Project = "",
    Filter = "",
    ReturnPartialSuccess = false,
};
// Make the request
PagedEnumerable<AcceleratorTypeList, AcceleratorType> response = acceleratorTypesClient.List(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (AcceleratorType item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (AcceleratorTypeList page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AcceleratorType item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AcceleratorType> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AcceleratorType item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

List(string, string, string, int?, CallSettings)

public virtual PagedEnumerable<AcceleratorTypeList, AcceleratorType> List(string project, string zone, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
AcceleratorTypesClient acceleratorTypesClient = AcceleratorTypesClient.Create();
// Initialize request argument(s)
string project = "";
string zone = "";
// Make the request
PagedEnumerable<AcceleratorTypeList, AcceleratorType> response = acceleratorTypesClient.List(project, zone);

// Iterate over all response items, lazily performing RPCs as required
foreach (AcceleratorType item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (AcceleratorTypeList page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AcceleratorType item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AcceleratorType> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AcceleratorType item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListAsync(ListAcceleratorTypesRequest, CallSettings)

public virtual PagedAsyncEnumerable<AcceleratorTypeList, AcceleratorType> ListAsync(ListAcceleratorTypesRequest request, CallSettings callSettings = null)

// Create client
AcceleratorTypesClient acceleratorTypesClient = await AcceleratorTypesClient.CreateAsync();
// Initialize request argument(s)
ListAcceleratorTypesRequest request = new ListAcceleratorTypesRequest
{
    Zone = "",
    OrderBy = "",
    Project = "",
    Filter = "",
    ReturnPartialSuccess = false,
};
// Make the request
PagedAsyncEnumerable<AcceleratorTypeList, AcceleratorType> response = acceleratorTypesClient.ListAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((AcceleratorType item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((AcceleratorTypeList page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AcceleratorType item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AcceleratorType> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AcceleratorType item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListAsync(string, string, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<AcceleratorTypeList, AcceleratorType> ListAsync(string project, string zone, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
AcceleratorTypesClient acceleratorTypesClient = await AcceleratorTypesClient.CreateAsync();
// Initialize request argument(s)
string project = "";
string zone = "";
// Make the request
PagedAsyncEnumerable<AcceleratorTypeList, AcceleratorType> response = acceleratorTypesClient.ListAsync(project, zone);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((AcceleratorType item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((AcceleratorTypeList page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AcceleratorType item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AcceleratorType> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AcceleratorType item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ShutdownDefaultChannelsAsync()

public static Task ShutdownDefaultChannelsAsync()