Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

Menggunakan database Amazon DynamoDB NoSQL

AWS SDK for .NET Mendukung Amazon DynamoDB, yang merupakan layanan database NoSQL cepat yang ditawarkan oleh. AWSSDK menyediakan tiga model pemrograman untuk berkomunikasi dengan DynamoDB: model tingkat rendah, model dokumen, dan model persistensi objek.

Informasi berikut memperkenalkan model ini dan API-nya, memberikan contoh tentang bagaimana dan kapan menggunakannya, dan memberi Anda tautan ke sumber daya pemrograman DynamoDB tambahan di file. AWS SDK for .NET

Model Tingkat Rendah

Model pemrograman tingkat rendah membungkus panggilan langsung ke layanan DynamoDB. Anda mengakses model ini melalui namespace Amazon.DynamoDBv2.

Dari ketiga model tersebut, model tingkat rendah mengharuskan Anda untuk menulis kode paling banyak. Misalnya, Anda harus mengonversi tipe data.NET ke padanannya di DynamoDB. Namun, model ini memberi Anda akses ke sebagian besar fitur.

Contoh berikut menunjukkan cara menggunakan model tingkat rendah untuk membuat tabel, memodifikasi tabel, dan menyisipkan item ke dalam tabel di DynamoDB.

Membuat Tabel

Dalam contoh berikut, Anda membuat tabel dengan menggunakan CreateTable metode AmazonDynamoDBClient kelas. CreateTableMetode ini menggunakan instance CreateTableRequest kelas yang berisi karakteristik seperti nama atribut item yang diperlukan, definisi kunci primer, dan kapasitas throughput. CreateTableMetode mengembalikan sebuah instance dari CreateTableResponse kelas.

// using Amazon.DynamoDBv2;
// using Amazon.DynamoDBv2.Model;

var client = new AmazonDynamoDBClient();

Console.WriteLine("Getting list of tables");
List<string> currentTables = client.ListTables().TableNames;
Console.WriteLine("Number of tables: " + currentTables.Count);
if (!currentTables.Contains("AnimalsInventory"))
{
    var request = new CreateTableRequest
    {
        TableName = "AnimalsInventory",
        AttributeDefinitions = new List<AttributeDefinition>
      {
        new AttributeDefinition
        {
          AttributeName = "Id",
          // "S" = string, "N" = number, and so on.
          AttributeType = "N"
        },
        new AttributeDefinition
        {
          AttributeName = "Type",
          AttributeType = "S"
        }
      },
        KeySchema = new List<KeySchemaElement>
      {
        new KeySchemaElement
        {
          AttributeName = "Id",
          // "HASH" = hash key, "RANGE" = range key.
          KeyType = "HASH"
        },
        new KeySchemaElement
        {
          AttributeName = "Type",
          KeyType = "RANGE"
        },
      },
        ProvisionedThroughput = new ProvisionedThroughput
        {
            ReadCapacityUnits = 10,
            WriteCapacityUnits = 5
        },
    };

    var response = client.CreateTable(request);

    Console.WriteLine("Table created with request ID: " +
      response.ResponseMetadata.RequestId);
}

Memverifikasi Bahwa Tabel Siap Dimodifikasi

Sebelum Anda dapat mengubah atau memodifikasi tabel, tabel harus siap untuk modifikasi. Contoh berikut menunjukkan cara menggunakan model tingkat rendah untuk memverifikasi bahwa tabel di DynamoDB sudah siap. Dalam contoh ini, tabel target untuk memeriksa direferensikan melalui DescribeTable metode AmazonDynamoDBClient kelas. Setiap lima detik, kode memeriksa nilai TableStatus properti tabel. Ketika status diatur keACTIVE, tabel siap untuk dimodifikasi.

// using Amazon.DynamoDBv2;
// using Amazon.DynamoDBv2.Model;

var client = new AmazonDynamoDBClient();      
var status = "";

do
{
  // Wait 5 seconds before checking (again).
  System.Threading.Thread.Sleep(TimeSpan.FromSeconds(5));
        
  try
  {
    var response = client.DescribeTable(new DescribeTableRequest
    {
      TableName = "AnimalsInventory"
    });

    Console.WriteLine("Table = {0}, Status = {1}",
      response.Table.TableName,
      response.Table.TableStatus);

    status = response.Table.TableStatus;
  }
  catch (ResourceNotFoundException)
  {
    // DescribeTable is eventually consistent. So you might
    //   get resource not found. 
  }

} while (status != TableStatus.ACTIVE);

Memasukkan Item ke dalam Tabel

Dalam contoh berikut, Anda menggunakan model tingkat rendah untuk menyisipkan dua item ke dalam tabel di DynamoDB. Setiap item dimasukkan melalui PutItem metode AmazonDynamoDBClient kelas, menggunakan instance PutItemRequest kelas. Masing-masing dari dua contoh PutItemRequest kelas mengambil nama tabel tempat item akan dimasukkan, dengan serangkaian nilai atribut item.

// using Amazon.DynamoDBv2;
// using Amazon.DynamoDBv2.Model;

var client = new AmazonDynamoDBClient();

var request1 = new PutItemRequest
{
  TableName = "AnimalsInventory",
  Item = new Dictionary<string, AttributeValue>
  {
    { "Id", new AttributeValue { N = "1" }},
    { "Type", new AttributeValue { S = "Dog" }},
    { "Name", new AttributeValue { S = "Fido" }}
  }
};

var request2 = new PutItemRequest
{
  TableName = "AnimalsInventory",
  Item = new Dictionary<string, AttributeValue>
  {
    { "Id", new AttributeValue { N = "2" }},
    { "Type", new AttributeValue { S = "Cat" }},
    { "Name", new AttributeValue { S = "Patches" }}
  }
};
        
client.PutItem(request1);
client.PutItem(request2);

Model Dokumen

Model pemrograman dokumen menyediakan cara yang lebih mudah untuk bekerja dengan data di DynamoDB. Model ini secara khusus ditujukan untuk mengakses tabel dan item dalam tabel. Anda mengakses model ini melalui Amazon.DynamoDBv2. DocumentModelnamespace.

Dibandingkan dengan model pemrograman tingkat rendah, model dokumen lebih mudah dikodekan terhadap data DynamoDB. Misalnya, Anda tidak perlu mengonversi sebanyak mungkin tipe data.NET ke padanannya di DynamoDB. Namun, model ini tidak menyediakan akses ke banyak fitur seperti model pemrograman tingkat rendah. Misalnya, Anda dapat menggunakan model ini untuk membuat, mengambil, memperbarui, dan menghapus item dalam tabel. Namun, untuk membuat tabel, Anda harus menggunakan model tingkat rendah. Dibandingkan dengan model persistensi objek, model ini mengharuskan Anda untuk menulis lebih banyak kode untuk menyimpan, memuat, dan menanyakan objek.NET.

Untuk informasi selengkapnya tentang model pemrograman dokumen DynamoDB, lihat .NET: Model dokumen dalam Panduan Pengembang Amazon DynamoDB.

Bagian berikut memberikan informasi tentang cara membuat representasi tabel DynamoDB yang diinginkan, dan contoh tentang cara menggunakan model dokumen untuk menyisipkan item ke dalam tabel dan mendapatkan item dari tabel.

Buat representasi tabel

Untuk melakukan operasi data menggunakan model dokumen, Anda harus terlebih dahulu membuat instance Table kelas yang mewakili tabel tertentu. Ada dua cara utama untuk melakukan ini.

LoadTable metode

Mekanisme pertama adalah menggunakan salah satu LoadTable metode statis Tablekelas, mirip dengan contoh berikut:

var client = new AmazonDynamoDBClient();
Table table = Table.LoadTable(client, "Reply");

TableBuilder

Mekanisme alternatif, TableBuilderkelas, diperkenalkan dalam versi 3.7.203 dari paket.DynamoDBv2. AWSSDK NuGet Mekanisme ini dapat mengatasi perilaku yang disebutkan di atas dengan menghapus panggilan metode implisit tertentu; khususnya, DescribeTable metode. Mekanisme ini digunakan dengan cara yang mirip dengan contoh berikut:

var client = new AmazonDynamoDBClient();
var table = new TableBuilder(client, "Reply")
    .AddHashKey("Id", DynamoDBEntryType.String)
    .AddRangeKey("ReplyDateTime", DynamoDBEntryType.String)
    .AddGlobalSecondaryIndex("PostedBy-Message-index", "Author", DynamoDBEntryType.String, "Message", DynamoDBEntryType.String)
    .Build();

Untuk informasi lebih lanjut tentang mekanisme alternatif ini, lihat lagi posting blog Peningkatan Pola Inisialisasi DynamoDB untuk. AWS SDK for .NET

Memasukkan item ke dalam tabel

Dalam contoh berikut, balasan dimasukkan ke dalam tabel Balas melalui PutItemAsync metode Table kelas. PutItemAsyncMetode ini mengambil contoh dari Document kelas; Document kelas hanyalah kumpulan atribut yang diinisialisasi.

using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DocumentModel;

// Create a representation of the "Reply" table
//  by using one of the mechanisms described previously.

// Then, add a reply to the table.
var newReply = new Document();
newReply["Id"] = Guid.NewGuid().ToString();
newReply["ReplyDateTime"] = DateTime.UtcNow;
newReply["PostedBy"] = "Author1";
newReply["Message"] = "Thank you!";

await table.PutItemAsync(newReply);

Mendapatkan item dari tabel

Dalam contoh berikut, balasan diambil melalui GetItemAsync metode Table kelas. Untuk menentukan balasan yang akan didapat, GetItemAsync metode ini menggunakan kunci hash-and-range utama dari balasan target.

using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DocumentModel;

// Create a representation of the "Reply" table
//  by using one of the mechanisms described previously.

// Then, get a reply from the table
//  where "guid" is the hash key and "datetime" is the range key.
var reply = await table.GetItemAsync(guid, datetime);
Console.WriteLine("Id = " + reply["Id"]);
Console.WriteLine("ReplyDateTime = " + reply["ReplyDateTime"]);
Console.WriteLine("PostedBy = " + reply["PostedBy"]);
Console.WriteLine("Message = " + reply["Message"]);

Contoh sebelumnya secara implisit mengubah nilai tabel menjadi string untuk metode ini. WriteLine Anda dapat melakukan konversi eksplisit dengan menggunakan berbagai metode “As [type]” kelas. DynamoDBEntry Misalnya, Anda dapat secara eksplisit mengonversi nilai Id dari tipe Primitive data ke GUID melalui metode: AsGuid()

var guid = reply["Id"].AsGuid();

Model Kegigihan Objek

Model pemrograman persistensi objek dirancang khusus untuk menyimpan, memuat, dan menanyakan objek.NET di DynamoDB. Anda mengakses model ini melalui Amazon.DynamoDBv2. DataModelnamespace.

Dari ketiga model tersebut, model persistensi objek adalah yang paling mudah untuk dikodekan setiap kali Anda menyimpan, memuat, atau menanyakan data DynamoDB. Misalnya, Anda bekerja dengan tipe data DynamoDB secara langsung. Namun, model ini hanya menyediakan akses ke operasi yang menyimpan, memuat, dan menanyakan objek.NET di DynamoDB. Misalnya, Anda dapat menggunakan model ini untuk membuat, mengambil, memperbarui, dan menghapus item dalam tabel. Namun, Anda harus terlebih dahulu membuat tabel Anda menggunakan model tingkat rendah, dan kemudian menggunakan model ini untuk memetakan kelas.NET Anda ke tabel.

Untuk informasi selengkapnya tentang model pemrograman persistensi objek DynamoDB, lihat .NET: Model persistensi objek di Panduan Pengembang Amazon DynamoDB.

Contoh berikut menunjukkan kepada Anda bagaimana mendefinisikan kelas.NET yang mewakili item DynamoDB, menggunakan instance dari kelas.NET untuk menyisipkan item ke dalam tabel DynamoDB, dan menggunakan instance dari kelas.NET untuk mendapatkan item dari tabel.

Mendefinisikan kelas.NET yang mewakili item dalam tabel

Dalam contoh berikut dari definisi kelas, DynamoDBTable atribut menentukan nama tabel, sedangkan DynamoDBHashKey dan DynamoDBRangeKey atribut model kunci hash-and-range utama tabel. DynamoDBGlobalSecondaryIndexHashKeyAtribut didefinisikan sehingga kueri untuk balasan oleh penulis tertentu dapat dibangun.

using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DataModel;

[DynamoDBTable("Reply")]
public class Reply
{
    [DynamoDBHashKey]
    public string Id { get; set; }

    [DynamoDBRangeKey(StoreAsEpoch = false)]
    public DateTime ReplyDateTime { get; set; }

    [DynamoDBGlobalSecondaryIndexHashKey("PostedBy-Message-Index",
        AttributeName ="PostedBy")]
    public string Author { get; set; }

    [DynamoDBGlobalSecondaryIndexRangeKey("PostedBy-Message-Index")]
    public string Message { get; set; }
}

Membuat konteks untuk model ketekunan objek

Untuk menggunakan model pemrograman persistensi objek untuk DynamoDB, Anda harus membuat konteks, yang menyediakan koneksi ke DynamoDB dan memungkinkan Anda mengakses tabel, melakukan berbagai operasi, dan menjalankan kueri.

Konteks dasar

Contoh berikut menunjukkan cara membuat konteks yang paling dasar.

using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DataModel;

var client = new AmazonDynamoDBClient();
var context = new DynamoDBContext(client);

Konteks dengan DisableFetchingTableMetadata properti

Contoh berikut menunjukkan bagaimana Anda mungkin juga mengatur DisableFetchingTableMetadata properti DynamoDBContextConfig kelas untuk mencegah panggilan implisit ke DescribeTable metode.

using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DataModel;

var client = new AmazonDynamoDBClient();
var context = new DynamoDBContext(client, new DynamoDBContextConfig
{
    DisableFetchingTableMetadata = true
});

Jika DisableFetchingTableMetadata properti diatur ke false (default), seperti yang ditunjukkan pada contoh pertama, Anda dapat menghilangkan atribut yang menggambarkan kunci dan struktur indeks item tabel dari Reply kelas. Atribut ini malah akan disimpulkan melalui panggilan implisit ke metode. DescribeTable Jika DisableFetchingTableMetadata diatur ketrue, seperti yang ditunjukkan pada contoh kedua, metode model ketekunan objek seperti SaveAsync dan QueryAsync bergantung sepenuhnya pada atribut yang didefinisikan di Reply kelas. Dalam hal ini, panggilan ke DescribeTable metode tidak terjadi.

Menggunakan instance dari kelas.NET untuk menyisipkan item ke dalam tabel

Dalam contoh ini, item dimasukkan melalui SaveAsync metode DynamoDBContext kelas, yang mengambil instance inisialisasi dari kelas.NET yang mewakili item.

using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DataModel;

// Create an appropriate context for the object persistence programming model,
//  examples of which have been described earlier.

// Create an object that represents the new item.
var reply = new Reply()
{
    Id = Guid.NewGuid().ToString(),
    ReplyDateTime = DateTime.UtcNow,
    Author = "Author1",
    Message = "Thank you!"
};

// Insert the item into the table.
await context.SaveAsync<Reply>(reply, new DynamoDBOperationConfig
{
    IndexName = "PostedBy-Message-index"
});

Menggunakan instance dari kelas.NET untuk mendapatkan item dari tabel

Dalam contoh ini, kueri dibuat untuk menemukan semua catatan “Author1" dengan menggunakan QueryAsync metode DynamoDBContext kelas. Kemudian, item diambil melalui GetNextSetAsync metode query.

using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DataModel;

// Create an appropriate context for the object persistence programming model,
//  examples of which have been described earlier.

// Construct a query that finds all replies by a specific author.
var query = context.QueryAsync<Reply>("Author1", new DynamoDBOperationConfig
{
    IndexName = "PostedBy-Message-index"
});

// Display the result.
var set = await query.GetNextSetAsync();
foreach (var item in set)
{
    Console.WriteLine("Id = " + item.Id);
    Console.WriteLine("ReplyDateTime = " + item.ReplyDateTime);
    Console.WriteLine("PostedBy = " + item.Author);
    Console.WriteLine("Message = " + item.Message);
}

Informasi tambahan tentang model persistensi objek

Contoh dan penjelasan yang ditunjukkan di atas terkadang menyertakan properti DynamoDBContext kelas yang disebutDisableFetchingTableMetadata. Properti ini, yang diperkenalkan dalam NuGet paket AWSSDK .DynamoDBv2 versi 3.7.203, memungkinkan Anda menghindari kondisi tertentu yang dapat menyebabkan latensi tambahan atau kebuntuan karena perilaku cold-start dan thread-pool. Untuk informasi lebih lanjut, lihat posting blog Peningkatan Pola Inisialisasi DynamoDB untuk. AWS SDK for .NET

Berikut ini adalah beberapa informasi tambahan tentang properti ini.

Informasi lain

Menggunakan AWS SDK for .NET untuk memprogram informasi DynamoDB dan contoh**

Informasi dan contoh model Tingkat Rendah

Informasi dan contoh model dokumen

Informasi dan contoh model ketekunan objek