Paginatoren

Einige AWS Dienste sammeln und speichern eine große Datenmenge, die Sie mithilfe der API Aufrufe von abrufen können. AWS SDK for .NET Wenn die Datenmenge, die Sie abrufen möchten, für einen einzelnen API Aufruf zu groß wird, können Sie die Ergebnisse mithilfe der Paginierung in besser verwaltbare Teile aufteilen.

Damit Sie die Paginierung durchführen können, stellen die Anforderungs- und Antwortobjekte für viele Service-Clients ein Fortsetzungstoken (normalerweise benannt) SDK bereit. NextToken Einige dieser Service-Clients bieten auch Paginatoren.

Mithilfe von Paginatoren können Sie den Mehraufwand vermeiden, der mit dem Fortsetzungstoken verbunden ist, der Schleifen, Statusvariablen, mehrere API Aufrufe usw. beinhalten kann. Wenn Sie einen Paginator verwenden, können Sie Daten aus einem AWS Dienst über eine einzige Codezeile, die Deklaration einer Schleife, abrufen. foreach Wenn zum API Abrufen der Daten mehrere Aufrufe erforderlich sind, erledigt der Paginator dies für Sie.

Wo finde ich Paginatoren?

Nicht alle Dienste bieten Paginatoren an. Eine Möglichkeit, festzustellen, ob ein Dienst einen Paginator für einen bestimmten Dienst bereitstellt, API besteht darin, sich die Definition einer Service-Client-Klasse in der Referenz anzusehen.AWS SDK for .NET API

Wenn Sie beispielsweise die Definition für die AmazonCloudWatchLogsClientKlasse untersuchen, sehen Sie eine Paginators Eigenschaft. Dies ist die Eigenschaft, die einen Paginator für Amazon CloudWatch Logs bereitstellt.

Was geben mir Paginatoren?

Paginatoren enthalten Eigenschaften, die es Ihnen ermöglichen, vollständige Antworten zu sehen. Sie enthalten in der Regel auch eine oder mehrere Eigenschaften, die es Ihnen ermöglichen, auf die interessantesten Teile der Antworten zuzugreifen, die wir die wichtigsten Ergebnisse nennen werden.

In den AmazonCloudWatchLogsClient bereits erwähnten Fällen enthält das Paginator Objekt beispielsweise eine Responses Eigenschaft mit dem vollständigen DescribeLogGroupsResponseObjekt aus dem API Aufruf. Diese Responses Eigenschaft enthält unter anderem eine Sammlung der Protokollgruppen.

Das Paginator-Objekt enthält auch ein wichtiges Ergebnis mit dem Namen. LogGroups Diese Eigenschaft enthält nur den Teil der Antwort mit den Protokollgruppen. Dieses wichtige Ergebnis ermöglicht es Ihnen, Ihren Code unter vielen Umständen zu reduzieren und zu vereinfachen.

Synchrone und asynchrone Paginierung

Paginatoren bieten sowohl synchrone als auch asynchrone Mechanismen für die Paginierung. Synchrone Paginierung ist in verfügbar. NETFramework-Projekte der Version 4.7.2 (oder höher). Asynchrone Paginierung ist in verfügbar. NETKernprojekte (. NETKern 3.1,. NET5, und so weiter).

Weil asynchrone Operationen und. NETCore wird empfohlen. Das nächste Beispiel zeigt Ihnen die asynchrone Paginierung. Informationen darüber, wie Sie dieselben Aufgaben mit synchroner Paginierung ausführen können und. NETFramework 4.7.2 (oder höher) wird nach dem Beispiel in gezeigt. Zusätzliche Überlegungen zu Paginatoren

Beispiel

Das folgende Beispiel zeigt Ihnen, wie Sie mit AWS SDK for .NET dem eine Liste von Protokollgruppen anzeigen können. Im Gegensatz dazu zeigt das Beispiel, wie Sie dies sowohl mit als auch ohne Paginatoren tun können. Bevor Sie sich den vollständigen Code ansehen, der später gezeigt wird, sollten Sie sich die folgenden Ausschnitte ansehen.

CloudWatch Loggruppen ohne Paginatoren abrufen

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

Abrufen von CloudWatch Protokollgruppen mithilfe von Paginatoren

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

Die Ergebnisse dieser beiden Snippets sind exakt identisch, sodass der Vorteil der Verwendung von Paginatoren deutlich zu erkennen ist.

Vollständiger Code

Dieser Abschnitt enthält relevante Referenzen und den vollständigen Code für dieses Beispiel.

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}");
        }
      }
    }
  }
}

Zusätzliche Überlegungen zu Paginatoren