Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
Paginateurs
Certains AWS services collectent et stockent une grande quantité de données, que vous pouvez récupérer en utilisant les API appels du AWS SDK for .NET. Si la quantité de données que vous souhaitez récupérer devient trop importante pour un seul API appel, vous pouvez diviser les résultats en éléments plus faciles à gérer grâce à la pagination.
Pour vous permettre d'effectuer la pagination, les objets de demande et de réponse de nombreux clients du service SDK fournissent un jeton de continuation (généralement nomméNextToken
). Certains de ces clients de services fournissent également des paginateurs.
Les paginateurs vous permettent d'éviter la surcharge liée au jeton de continuation, qui peut impliquer des boucles, des variables d'état, des API appels multiples, etc. Lorsque vous utilisez un paginateur, vous pouvez récupérer les données d'un AWS service par le biais d'une seule ligne de code, la déclaration d'une foreach
boucle. Si plusieurs API appels sont nécessaires pour récupérer les données, le paginateur s'en charge pour vous.
Où puis-je trouver des paginateurs ?
Tous les services ne proposent pas de paginateurs. Une façon de déterminer si un service fournit un paginateur pour un service en particulier API consiste à examiner la définition d'une classe de client de service dans la AWS SDK for .NET API référence.
Par exemple, si vous examinez la définition de la AmazonCloudWatchLogsClientclasse, vous voyez une Paginators
propriété. Il s'agit de la propriété qui fournit un paginateur pour Amazon CloudWatch Logs.
Que m'apportent les paginateurs ?
Les paginateurs contiennent des propriétés qui vous permettent de voir les réponses complètes. Ils contiennent également généralement une ou plusieurs propriétés qui vous permettent d'accéder aux parties les plus intéressantes des réponses, que nous appellerons les résultats clés.
Par exemple, dans ce qui AmazonCloudWatchLogsClient
a été mentionné précédemment, l'Paginator
objet contient une Responses
propriété contenant l'DescribeLogGroupsResponseobjet complet de l'APIappel. Cette Responses
propriété contient, entre autres, un ensemble de groupes de journaux.
L'objet Paginator contient également un résultat clé nommé. LogGroups
Cette propriété contient uniquement la partie de la réponse consacrée aux groupes de journaux. L'obtention de ce résultat clé vous permet de réduire et de simplifier votre code dans de nombreuses circonstances.
Pagination synchrone ou asynchrone
Les paginateurs fournissent des mécanismes de pagination synchrones et asynchrones. La pagination synchrone est disponible dans. NETProjets Framework 4.7.2 (ou version ultérieure). La pagination asynchrone est disponible dans. NETProjets principaux (. NETNoyau 3.1,. NET5, et ainsi de suite).
Parce que les opérations asynchrones et. NETLes noyaux sont recommandés, l'exemple qui suit vous montre la pagination asynchrone. Informations sur la façon d'effectuer les mêmes tâches à l'aide de la pagination synchrone et. NETLe Framework 4.7.2 (ou version ultérieure) est affiché après l'exemple dansConsidérations supplémentaires pour les paginateurs.
Exemple
L'exemple suivant montre comment utiliser le pour AWS SDK for .NET afficher une liste de groupes de journaux. Pour le contraste, l'exemple montre comment procéder avec et sans paginateurs. Avant d'examiner le code complet, présenté plus loin, considérez les extraits suivants.
Obtenir des groupes de CloudWatch logs sans paginateurs
// Loop as many times as needed to get all the log groups
var request = new DescribeLogGroupsRequest{Limit = LogGroupLimit};
do
{
Console.WriteLine($"Getting up to {LogGroupLimit} log groups...");
var response = await cwClient.DescribeLogGroupsAsync(request);
foreach(var logGroup in response.LogGroups)
{
Console.WriteLine($"{logGroup.LogGroupName}");
}
request.NextToken = response.NextToken;
} while(!string.IsNullOrEmpty(request.NextToken));
Obtenir des groupes de CloudWatch journaux à l'aide de paginateurs
// No need to loop to get all the log groups--the SDK does it for us behind the scenes
var paginatorForLogGroups =
cwClient.Paginators.DescribeLogGroups(new DescribeLogGroupsRequest());
await foreach(var logGroup in paginatorForLogGroups.LogGroups)
{
Console.WriteLine(logGroup.LogGroupName);
}
Les résultats de ces deux extraits étant exactement les mêmes, l'avantage de l'utilisation de paginateurs est clairement visible.
Note
Avant d'essayer de créer et d'exécuter le code complet, assurez-vous d'avoir configuré votre environnement et votre projet.
Vous pourriez également avoir besoin du Microsoft.Bcl. AsyncInterfacesIAsyncEnumerable
Code complet
Cette section présente les références pertinentes et le code complet de cet exemple.
NuGet colis :
Éléments de programmation :
-
Espace de noms Amazon. CloudWatch
Classe AmazonCloudWatchLogsClient
-
Espace de noms Amazon. CloudWatchLogs.Modèle
Classe DescribeLogGroupsRequest
Classe DescribeLogGroupsResponse
Classe LogGroup
using System;
using System.Threading.Tasks;
using Amazon.CloudWatchLogs;
using Amazon.CloudWatchLogs.Model;
namespace CWGetLogGroups
{
class Program
{
// A small limit for demonstration purposes
private const int LogGroupLimit = 3;
//
// Main method
static async Task Main(string[] args)
{
var cwClient = new AmazonCloudWatchLogsClient();
await DisplayLogGroupsWithoutPaginators(cwClient);
await DisplayLogGroupsWithPaginators(cwClient);
}
//
// Method to get CloudWatch log groups without paginators
private static async Task DisplayLogGroupsWithoutPaginators(IAmazonCloudWatchLogs cwClient)
{
Console.WriteLine("\nGetting list of CloudWatch log groups without using paginators...");
Console.WriteLine("------------------------------------------------------------------");
// Loop as many times as needed to get all the log groups
var request = new DescribeLogGroupsRequest{Limit = LogGroupLimit};
do
{
Console.WriteLine($"Getting up to {LogGroupLimit} log groups...");
DescribeLogGroupsResponse response = await cwClient.DescribeLogGroupsAsync(request);
foreach(LogGroup logGroup in response.LogGroups)
{
Console.WriteLine($"{logGroup.LogGroupName}");
}
request.NextToken = response.NextToken;
} while(!string.IsNullOrEmpty(request.NextToken));
}
//
// Method to get CloudWatch log groups by using paginators
private static async Task DisplayLogGroupsWithPaginators(IAmazonCloudWatchLogs cwClient)
{
Console.WriteLine("\nGetting list of CloudWatch log groups by using paginators...");
Console.WriteLine("-------------------------------------------------------------");
// Access the key results; i.e., the log groups
// No need to loop to get all the log groups--the SDK does it for us behind the scenes
Console.WriteLine("\nFrom the key results...");
Console.WriteLine("------------------------");
IDescribeLogGroupsPaginator paginatorForLogGroups =
cwClient.Paginators.DescribeLogGroups(new DescribeLogGroupsRequest());
await foreach(LogGroup logGroup in paginatorForLogGroups.LogGroups)
{
Console.WriteLine(logGroup.LogGroupName);
}
// Access the full response
// Create a new paginator, do NOT reuse the one from above
Console.WriteLine("\nFrom the full response...");
Console.WriteLine("--------------------------");
IDescribeLogGroupsPaginator paginatorForResponses =
cwClient.Paginators.DescribeLogGroups(new DescribeLogGroupsRequest());
await foreach(DescribeLogGroupsResponse response in paginatorForResponses.Responses)
{
Console.WriteLine($"Content length: {response.ContentLength}");
Console.WriteLine($"HTTP result: {response.HttpStatusCode}");
Console.WriteLine($"Metadata: {response.ResponseMetadata}");
Console.WriteLine("Log groups:");
foreach(LogGroup logGroup in response.LogGroups)
{
Console.WriteLine($"\t{logGroup.LogGroupName}");
}
}
}
}
}
Considérations supplémentaires pour les paginateurs
-
Les paginateurs ne peuvent pas être utilisés plus d'une fois
Si vous avez besoin des résultats d'un AWS paginateur spécifique à plusieurs endroits de votre code, vous ne devez pas utiliser un objet de pagination plusieurs fois. Créez plutôt un nouveau paginateur chaque fois que vous en avez besoin. Ce concept est illustré dans l'exemple de code précédent de la
DisplayLogGroupsWithPaginators
méthode.
-
Pagination synchrone
La pagination synchrone est disponible pour. NETProjets Framework 4.7.2 (ou version ultérieure).
Avertissement
À compter du 15 août 2024, le AWS SDK for .NET support de. NETFramework 3.5 et modifiera le minimum. NETVersion Framework vers 4.7.2. Pour plus d'informations, consultez le billet de blog Changements importants à venir. NETObjectifs des cadres 3.5 et 4.5 du AWS SDK for .NET
. Pour voir cela, créez un. NETProjetez Framework 4.7.2 (ou version ultérieure) et copiez-y le code précédent. Supprimez ensuite simplement le
await
mot-clé des deux appels deforeach
pagination, comme indiqué dans l'exemple suivant./*await*/ foreach(var logGroup in paginatorForLogGroups.LogGroups) { Console.WriteLine(logGroup.LogGroupName); }
Créez et exécutez le projet pour obtenir les mêmes résultats que ceux obtenus avec la pagination asynchrone.