Version 4 (V4) von AWS SDK für .NET wurde veröffentlicht\!

Informationen zu wichtigen Änderungen und zur Migration Ihrer Anwendungen finden Sie im [Migrationsthema](https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/net-dg-v4.html).

 [https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/net-dg-v4.html](https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/net-dg-v4.html)

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Verwenden von paginierten Ergebnissen in der AWS SDK für .NET
<a name="paginators"></a>

Einige AWS Dienste sammeln und speichern eine große Datenmenge, die Sie mithilfe der API-Aufrufe von abrufen können. AWS SDK für .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 überschaubarere Teile aufteilen. 

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

Mit 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 mehrere API-Aufrufe erforderlich sind, um die Daten abzurufen, erledigt der Paginator dies für Sie.

## Wo finde ich Paginatoren?
<a name="paginators-find-them"></a>

Nicht alle Dienste bieten Paginatoren. [Eine Möglichkeit, festzustellen, ob ein Dienst einen Paginator für eine bestimmte API bereitstellt, besteht darin, sich die Definition einer Service-Client-Klasse in der API-Referenz anzusehen.AWS SDK für .NET](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/)

Wenn Sie beispielsweise die Definition für die [AmazonCloudWatchLogsClient](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/CloudWatchLogs/TCloudWatchLogsClient.html)Klasse untersuchen, sehen Sie eine `Paginators` Eigenschaft. Dies ist die Eigenschaft, die einen Paginator für Amazon CloudWatch Logs bereitstellt.

## Was geben mir Paginatoren?
<a name="paginators-use-them"></a>

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 zuvor `AmazonCloudWatchLogsClient` genannten Fällen enthält das `Paginator` Objekt beispielsweise eine `Responses` Eigenschaft mit dem vollständigen [DescribeLogGroupsResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/CloudWatchLogs/TDescribeLogGroupsResponse.html)Objekt 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
<a name="paginators-sync-async"></a>

Paginatoren bieten sowohl synchrone als auch asynchrone Mechanismen für die Paginierung. Synchrone Paginierung ist in Projekten von.NET Framework 4.7.2 (oder höher) verfügbar. Asynchrone Paginierung ist in .NET Core-Projekten (.NET Core 3.1, .NET 5 usw.) verfügbar.

Da asynchrone Operationen und .NET Core empfohlen werden, zeigt Ihnen das folgende Beispiel die asynchrone Paginierung. Informationen dazu, wie Sie dieselben Aufgaben mit synchroner Paginierung und .NET Framework 4.7.2 (oder höher) ausführen können, finden Sie nach dem Beispiel unter. [Zusätzliche Überlegungen zu Paginatoren](#paginators-additional)

## Beispiel
<a name="paginators-example"></a>

Das folgende Beispiel zeigt Ihnen, wie Sie mit dem AWS SDK für .NET 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.

**Anmerkung**  
Bevor Sie versuchen, den vollständigen Code zu erstellen und auszuführen, stellen Sie sicher, dass Sie Ihre Umgebung und [Ihr Projekt eingerichtet](net-dg-config.md) haben.  
Möglicherweise benötigen Sie auch die [Microsoft.Bcl. AsyncInterfaces](https://www.nuget.org/packages/Microsoft.Bcl.AsyncInterfaces/) NuGet Paket, weil asynchrone Paginatoren die Schnittstelle verwenden. `IAsyncEnumerable`

### Vollständiger Code
<a name="paginators-complete-code"></a>

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

#### SDK-Referenzen
<a name="w2aac13c13c23c19b5b1"></a>

NuGet Pakete:
+ [AWSSDK.CloudWatch](https://www.nuget.org/packages/AWSSDK.CloudWatch)

Elemente der Programmierung:
+ Namespace [Amazon. CloudWatch](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/CloudWatch/NCloudWatch.html)

  Klasse [AmazonCloudWatchLogsClient](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/CloudWatchLogs/TCloudWatchLogsClient.html)
+ Namespace [Amazon. CloudWatchLogs.Modell](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/CloudWatchLogs/NCloudWatchLogsModel.html)

  Klasse [DescribeLogGroupsRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/CloudWatchLogs/TDescribeLogGroupsRequest.html)

  Klasse [DescribeLogGroupsResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/CloudWatchLogs/TDescribeLogGroupsResponse.html)

  Klasse [LogGroup](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/CloudWatchLogs/TLogGroup.html)

#### Vollständiger Code
<a name="w2aac13c13c23c19b7b1"></a>

```
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
<a name="paginators-additional"></a>
+ **Paginatoren können nicht mehr als einmal verwendet werden**

  Wenn Sie die Ergebnisse eines bestimmten AWS Paginators an mehreren Stellen in Ihrem Code benötigen, dürfen Sie ein Paginator-Objekt nicht mehr als einmal verwenden. Erstellen Sie stattdessen jedes Mal, wenn Sie ihn benötigen, einen neuen Paginator. Dieses Konzept wird im vorherigen Beispielcode der Methode gezeigt. `DisplayLogGroupsWithPaginators`
+ **Synchrone Paginierung**

  Synchrone Paginierung ist für Projekte von.NET Framework 4.7.2 (oder höher) verfügbar.

  Um dies zu sehen, erstellen Sie ein.NET Framework 4.7.2 (oder höher) -Projekt und kopieren Sie den vorherigen Code hinein. Entfernen Sie dann einfach das `await` Schlüsselwort aus den beiden `foreach` Paginator-Aufrufen, wie im folgenden Beispiel gezeigt.

  ```
  /*await*/ foreach(var logGroup in paginatorForLogGroups.LogGroups)
  {
    Console.WriteLine(logGroup.LogGroupName);
  }
  ```

  Erstellen Sie das Projekt und führen Sie es aus, um dieselben Ergebnisse zu erzielen wie bei der asynchronen Paginierung.