Menggunakan hasil yang dipaginasi di AWS SDK untuk .NET

Beberapa AWS layanan mengumpulkan dan menyimpan sejumlah besar data, yang dapat Anda ambil dengan menggunakan panggilan API dari AWS SDK untuk .NET. Jika jumlah data yang ingin Anda ambil menjadi terlalu besar untuk satu panggilan API, Anda dapat memecah hasilnya menjadi bagian-bagian yang lebih mudah dikelola melalui penggunaan pagination.

Untuk memungkinkan Anda melakukan pagination, objek permintaan dan respons untuk banyak klien layanan di SDK menyediakan token lanjutan (biasanya diberi namaNextToken). Beberapa klien layanan ini juga menyediakan paginator .

Paginator memungkinkan Anda untuk menghindari overhead token lanjutan, yang mungkin melibatkan loop, variabel status, beberapa panggilan API, dan sebagainya. Ketika Anda menggunakan paginator, Anda dapat mengambil data dari AWS layanan melalui satu baris kode, deklarasi foreach loop. Jika beberapa panggilan API diperlukan untuk mengambil data, paginator menangani ini untuk Anda.

Di mana saya menemukan paginator?

Tidak semua layanan menyediakan paginator. Salah satu cara untuk menentukan apakah layanan menyediakan paginator untuk API tertentu adalah dengan melihat definisi kelas klien layanan di Referensi AWS SDK untuk .NET API.

Misalnya, jika Anda memeriksa definisi untuk AmazonCloudWatchLogsClient kelas, Anda melihat Paginators properti. Ini adalah properti yang menyediakan paginator untuk Amazon CloudWatch Logs.

Apa yang diberikan paginator kepada saya?

Paginator berisi properti yang memungkinkan Anda melihat tanggapan penuh. Mereka juga biasanya berisi satu atau lebih properti yang memungkinkan Anda mengakses bagian tanggapan yang paling menarik, yang akan kami sebut hasil utama.

Misalnya, dalam yang AmazonCloudWatchLogsClient disebutkan sebelumnya, Paginator objek berisi Responses properti dengan DescribeLogGroupsResponse objek lengkap dari panggilan API. Pro Responses perti ini berisi, antara lain, kumpulan grup log.

Objek Paginator juga berisi satu hasil kunci bernama. LogGroups Properti ini hanya menyimpan bagian grup log dari respons. Memiliki hasil kunci ini memungkinkan Anda untuk mengurangi dan menyederhanakan kode Anda dalam banyak keadaan.

Paginasi sinkron vs. asinkron

Paginator menyediakan mekanisme sinkron dan asinkron untuk paginasi. Pagination sinkron tersedia di proyek.NET Framework 4.7.2 (atau yang lebih baru). Pagination asinkron tersedia di proyek.NET Core (.NET Core 3.1, .NET 5, dan seterusnya).

Karena operasi asinkron dan.NET Core direkomendasikan, contoh berikutnya menunjukkan pagination asinkron. Informasi tentang cara melakukan tugas yang sama menggunakan pagination sinkron dan.NET Framework 4.7.2 (atau yang lebih baru) ditampilkan setelah contoh di. Pertimbangan tambahan untuk paginator

Contoh

Contoh berikut menunjukkan cara menggunakan AWS SDK untuk .NET untuk menampilkan daftar grup log. Sebagai kontras, contoh menunjukkan bagaimana melakukan ini baik dengan dan tanpa paginator. Sebelum melihat kode lengkap, yang ditampilkan nanti, pertimbangkan cuplikan berikut.

Mendap CloudWatch atkan grup log tanpa paginator

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

Mend CloudWatch apatkan grup log dengan menggunakan paginator

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

Hasil dari kedua cuplikan ini persis sama, sehingga keuntungan dalam menggunakan paginator dapat dilihat dengan jelas.

Kode lengkap

Bagian ini menunjukkan referensi yang relevan dan kode lengkap untuk contoh ini.

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

Pertimbangan tambahan untuk paginator