Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Antarmuka pemrograman tingkat tinggi untuk DynamoDB
bookAuthors;
private String someProp;
@DynamoDBHashKey(attributeName="Id")
public Integer getId() { return id; }
public void setId(Integer id) {this.id = id; }
@DynamoDBAttribute(attributeName="Title")
public String getTitle() {return title; }
public void setTitle(String title) { this.title = title; }
@DynamoDBAttribute(attributeName="ISBN")
public String getISBN() { return ISBN; }
public void setISBN(String ISBN) { this.ISBN = ISBN; }
@DynamoDBAttribute(attributeName="Authors")
public Set getBookAuthors() { return bookAuthors; }
public void setBookAuthors(Set bookAuthors) { this.bookAuthors = bookAuthors; }
@DynamoDBIgnore
public String getSomeProp() { return someProp; }
public void setSomeProp(String someProp) { this.someProp = someProp; }
}
```
Dalam kode sebelumnya, anotasi `@DynamoDBTable` memetakan kelas `CatalogItem` ke tabel `ProductCatalog`. Anda dapat menyimpan masing-masing instans kelas sebagai item dalam tabel. Dalam definisi kelas, anotasi `@DynamoDBHashKey` memetakan properti `Id` ke kunci primer.
Secara default, properti kelas memetakan atribut nama yang sama dalam tabel. Properti `Title` dan `ISBN` memetakan atribut nama yang sama di tabel.
Anotasi `@DynamoDBAttribute` bersifat opsional saat nama atribut DynamoDB cocok dengan nama properti yang dinyatakan di kelas. Jika namanya berbeda, gunakan anotasi ini dengan parameter `attributeName` untuk menentukan atribut DynamoDB yang sesuai dengan properti ini.
Dalam contoh sebelumnya, `@DynamoDBAttribute` anotasi ditambahkan ke setiap properti untuk memastikan bahwa nama properti cocok persis dengan tabel yang dibuat pada langkah sebelumnya, dan agar konsisten dengan nama atribut yang digunakan dalam contoh kode lain dalam panduan ini.
Definisi kelas Anda dapat memiliki properti yang tidak dipetakan ke setiap atribut dalam tabel. Anda mengidentifikasi properti ini dengan menambahkan anotasi `@DynamoDBIgnore`. Dalam contoh sebelumnya, properti `SomeProp` ditandai dengan anotasi `@DynamoDBIgnore`. Saat Anda mengunggah instans `CatalogItem` ke tabel, instans `DynamoDBMapper` tidak menyertakan properti `SomeProp`. Selain itu, pemeta tidak mengembalikan atribut ini ketika Anda mengambil item dari tabel.
Setelah menentukan kelas pemetaan, Anda dapat menggunakan metode `DynamoDBMapper` untuk menulis instans kelas tersebut untuk item yang sesuai dalam tabel `Catalog`. Contoh kode berikut mendemonstrasikan teknik ini.
```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDBMapper mapper = new DynamoDBMapper(client);
CatalogItem item = new CatalogItem();
item.setId(102);
item.setTitle("Book 102 Title");
item.setISBN("222-2222222222");
item.setBookAuthors(new HashSet(Arrays.asList("Author 1", "Author 2")));
item.setSomeProp("Test");
mapper.save(item);
```
Contoh kode berikut menunjukkan cara mengambil item dan mengakses beberapa atributnya.
```
CatalogItem partitionKey = new CatalogItem();
partitionKey.setId(102);
DynamoDBQueryExpression queryExpression = new DynamoDBQueryExpression()
.withHashKeyValues(partitionKey);
List itemList = mapper.query(CatalogItem.class, queryExpression);
for (int i = 0; i < itemList.size(); i++) {
System.out.println(itemList.get(i).getTitle());
System.out.println(itemList.get(i).getBookAuthors());
}
```
`DynamoDBMapper` menawarkan cara natural yang intuitif untuk menggunakan data DynamoDB dalam Java. Ini juga menyediakan beberapa fitur bawaan, seperti penguncian optimis, transaksi ACID, nilai kunci urutan dan kunci partisi yang dibuat secara otomatis, serta objek penentuan versi.
# Kelas Dynamo DBMapper
eav = new HashMap();
eav.put(":v1", new AttributeValue().withS(partitionKey));
eav.put(":v2",new AttributeValue().withS(twoWeeksAgoStr.toString()));
DynamoDBQueryExpression queryExpression = new DynamoDBQueryExpression()
.withKeyConditionExpression("Id = :v1 and ReplyDateTime > :v2")
.withExpressionAttributeValues(eav);
List latestReplies = mapper.query(Reply.class, queryExpression);
```
Kueri ini mengembalikan koleksi objek `Reply`.
Secara default, metode `query` mengembalikan koleksi "lazy-loaded". Metode ini awalnya hanya mengembalikan satu halaman hasil, lalu membuat panggilan layanan untuk halaman berikutnya jika diperlukan. Untuk mendapatkan semua item yang cocok, iterasikan ke koleksi `latestReplies`.
Perhatikan bahwa memanggil metode `size()` pada koleksi akan memuat setiap hasil untuk memberikan jumlah yang akurat. Hal ini dapat mengakibatkan penggunaan banyak throughput yang disediakan, dan bahkan bisa menghabiskan semua memori di JVM Anda pada tabel yang sangat besar.
Untuk mencari indeks, Anda harus membuat model indeks sebagai kelas pemeta terlebih dahulu. Misalkan `Reply` tabel memiliki indeks sekunder global bernama *PostedBy-Message-Index*. Kunci partisi untuk indeks ini adalah `PostedBy`, dan kunci urutannya adalah `Message`. Definisi kelas untuk item dalam indeks akan tampak seperti berikut ini.
```
@DynamoDBTable(tableName="Reply")
public class PostedByMessage {
private String postedBy;
private String message;
@DynamoDBIndexHashKey(globalSecondaryIndexName = "PostedBy-Message-Index", attributeName = "PostedBy")
public String getPostedBy() { return postedBy; }
public void setPostedBy(String postedBy) { this.postedBy = postedBy; }
@DynamoDBIndexRangeKey(globalSecondaryIndexName = "PostedBy-Message-Index", attributeName = "Message")
public String getMessage() { return message; }
public void setMessage(String message) { this.message = message; }
// Additional properties go here.
}
```
Anotasi `@DynamoDBTable` menunjukkan bahwa indeks ini terkait dengan tabel `Reply`. `@DynamoDBIndexHashKey`Anotasi menunjukkan kunci partisi (*PostedBy*) dari indeks, dan `@DynamoDBIndexRangeKey` menunjukkan kunci sortir (*Pesan*) indeks.
Sekarang, Anda dapat menggunakan `DynamoDBMapper` untuk mengkueri indeks, mengambil subset pesan yang diposting oleh pengguna tertentu. Anda tidak perlu menentukan nama indeks jika Anda tidak memiliki pemetaan yang bertentangan di seluruh tabel dan indeks serta pemetaan sudah dibuat di mapper. Pemeta akan menyimpulkan berdasarkan kunci primer dan kunci urutan. Kode berikut mengkueri indeks sekunder global. Karena indeks sekunder global mendukung bacaan akhir konsisten tetapi bukan bacaan sangat konsisten, Anda harus menentukan `withConsistentRead(false)`.
```
HashMap eav = new HashMap();
eav.put(":v1", new AttributeValue().withS("User A"));
eav.put(":v2", new AttributeValue().withS("DynamoDB"));
DynamoDBQueryExpression queryExpression = new DynamoDBQueryExpression()
.withIndexName("PostedBy-Message-Index")
.withConsistentRead(false)
.withKeyConditionExpression("PostedBy = :v1 and begins_with(Message, :v2)")
.withExpressionAttributeValues(eav);
List iList = mapper.query(PostedByMessage.class, queryExpression);
```
Kueri ini mengembalikan koleksi objek `PostedByMessage`.
## queryPage
eav = new HashMap();
eav.put(":v1", new AttributeValue().withS("2015"));
DynamoDBScanExpression scanExpression = new DynamoDBScanExpression()
.withFilterExpression("begins_with(ReplyDateTime,:v1)")
.withExpressionAttributeValues(eav);
List replies = mapper.scan(Reply.class, scanExpression);
```
Secara default, metode `scan` mengembalikan koleksi "lazy-loaded". Metode ini awalnya hanya mengembalikan satu halaman hasil, lalu membuat panggilan layanan untuk halaman berikutnya jika diperlukan. Untuk mendapatkan semua item yang cocok, iterasikan ke koleksi `replies`.
Perhatikan bahwa memanggil metode `size()` pada koleksi akan memuat setiap hasil untuk memberikan jumlah yang akurat. Hal ini dapat mengakibatkan penggunaan banyak throughput yang disediakan, dan bahkan bisa menghabiskan semua memori di JVM Anda pada tabel yang sangat besar.
Untuk memindai indeks, Anda harus membuat model indeks sebagai kelas pemeta terlebih dahulu. Misalkan tabel `Reply` memiliki indeks sekunder global bernama `PostedBy-Message-Index`. Kunci partisi untuk indeks ini adalah `PostedBy`, dan kunci urutannya adalah `Message`. Kelas pemeta untuk indeks ini ditampilkan di bagian [kueri](#DynamoDBMapper.Methods.query). Kelas ini menggunakan anotasi `@DynamoDBIndexHashKey` dan `@DynamoDBIndexRangeKey` untuk menentukan kunci partisi indeks dan kunci urutan.
Contoh kode berikut memindai `PostedBy-Message-Index`. Contoh kode ini tidak menggunakan filter pemindaian, sehingga semua item dalam indeks dikembalikan kepada Anda.
```
DynamoDBScanExpression scanExpression = new DynamoDBScanExpression()
.withIndexName("PostedBy-Message-Index")
.withConsistentRead(false);
List iList = mapper.scan(PostedByMessage.class, scanExpression);
Iterator indexItems = iList.iterator();
```
## scanPage
eav = new HashMap();
eav.put(":n", new AttributeValue().withN("100"));
DynamoDBScanExpression scanExpression = new DynamoDBScanExpression()
.withFilterExpression("Price <= :n")
.withExpressionAttributeValues(eav);
List scanResult = mapper.parallelScan(Product.class, scanExpression, numberOfThreads);
```
## batchSave
itemsToGet = new ArrayList();
ForumItem forumItem = new ForumItem();
forumItem.setForumName("Amazon DynamoDB");
itemsToGet.add(forumItem);
ThreadItem threadItem = new ThreadItem();
threadItem.setForumName("Amazon DynamoDB");
threadItem.setSubject("Amazon DynamoDB thread 1 message text");
itemsToGet.add(threadItem);
Map> items = mapper.batchLoad(itemsToGet);
```
## batchDelete
objectsToWrite = Arrays.asList(forumItem, threadItem);
List objectsToDelete = Arrays.asList(book3);
mapper.batchWrite(objectsToWrite, objectsToDelete);
```
## transactionWrite
getBookAuthors() { return BookAuthors; }
public void setBookAuthors(List BookAuthors) { this.BookAuthors = BookAuthors; }
```
`DynamoDBMapper` menggunakan `Authors` sebagai nama atribut saat menyimpan objek ke tabel.
## Dinamo DBAuto GeneratedKey
bookAuthors;
private String someProp;
private Long version;
@DynamoDBHashKey(attributeName="Id")
public Integer getId() { return id; }
public void setId(Integer Id) { this.id = Id; }
@DynamoDBAttribute(attributeName="Title")
public String getTitle() { return title; }
public void setTitle(String title) { this.title = title; }
@DynamoDBAttribute(attributeName="ISBN")
public String getISBN() { return ISBN; }
public void setISBN(String ISBN) { this.ISBN = ISBN;}
@DynamoDBAttribute(attributeName = "Authors")
public Set getBookAuthors() { return bookAuthors; }
public void setBookAuthors(Set bookAuthors) { this.bookAuthors = bookAuthors; }
@DynamoDBIgnore
public String getSomeProp() { return someProp;}
public void setSomeProp(String someProp) {this.someProp = someProp;}
@DynamoDBVersionAttribute
public Long getVersion() { return version; }
public void setVersion(Long version) { this.version = version;}
}
```
Anda dapat menerapkan anotasi `@DynamoDBVersionAttribute` untuk jenis yang dapat dinihilkan yang diberikan oleh kelas pembungkus primitif yang menyediakan jenis yang dapat di-null-kan, seperti `Long` dan `Integer`.
Penguncian optimis memiliki dampak sebagai berikut pada metode `DynamoDBMapper` ini:
+ `save` — Untuk item baru, `DynamoDBMapper` menetapkan nomor versi awal 1. Jika Anda mengambil item, memperbarui satu atau beberapa propertinya, dan mencoba untuk menyimpan perubahan, operasi simpan hanya akan berhasil jika nomor versi di sisi klien dan sisi server cocok. `DynamoDBMapper` menambah nomor versi secara otomatis.
+ `delete` — Metode `delete` mengambil sebuah objek sebagai parameter, dan `DynamoDBMapper` melakukan pemeriksaan versi sebelum menghapus item. Pemeriksaan versi dapat dinonaktifkan jika `DynamoDBMapperConfig.SaveBehavior.CLOBBER` ditentukan dalam permintaan.
Implementasi internal penguncian optimis dalam `DynamoDBMapper` menggunakan pembaruan bersyarat dan dukungan penghapusan bersyarat yang disediakan oleh DynamoDB.
+ `transactionWrite` —
+ `Put` — Untuk item baru, `DynamoDBMapper` menetapkan nomor versi awal 1. Jika Anda mengambil item, memperbarui satu atau beberapa propertinya, dan mencoba untuk menyimpan perubahan, operasi masukkan hanya akan berhasil jika nomor versi di sisi klien dan sisi server cocok. `DynamoDBMapper` menambah nomor versi secara otomatis.
+ `Update` — Untuk item baru, `DynamoDBMapper` menetapkan nomor versi awal 1. Jika Anda mengambil item, memperbarui satu atau beberapa propertinya, dan mencoba untuk menyimpan perubahan, operasi perbarui hanya akan berhasil jika nomor versi di sisi klien dan sisi server cocok. `DynamoDBMapper` menambah nomor versi secara otomatis.
+ `Delete` — `DynamoDBMapper` melakukan pemeriksaan versi sebelum menghapus item. Operasi hapus hanya akan berhasil jika nomor versi pada sisi klien dan sisi server cocok.
+ `ConditionCheck` — Anotasi `@DynamoDBVersionAttribute` tidak didukung untuk operasi `ConditionCheck`. An SdkClientException akan dilemparkan ketika `ConditionCheck` item dianotasi dengan. `@DynamoDBVersionAttribute`
## Menonaktifkan penguncian optimis
(Arrays.asList("Author1", "Author2")));
book.setDimensions(dimType);
DynamoDBMapper mapper = new DynamoDBMapper(client);
mapper.save(book);
Book bookRetrieved = mapper.load(Book.class, 502);
System.out.println("Book info: " + "\n" + bookRetrieved);
bookRetrieved.getDimensions().setHeight("9.0");
bookRetrieved.getDimensions().setLength("12.0");
bookRetrieved.getDimensions().setThickness("2.0");
mapper.save(bookRetrieved);
bookRetrieved = mapper.load(Book.class, 502);
System.out.println("Updated book info: " + "\n" + bookRetrieved);
}
@DynamoDBTable(tableName = "ProductCatalog")
public static class Book {
private int id;
private String title;
private String ISBN;
private Set bookAuthors;
private DimensionType dimensionType;
// Partition key
@DynamoDBHashKey(attributeName = "Id")
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@DynamoDBAttribute(attributeName = "Title")
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
@DynamoDBAttribute(attributeName = "ISBN")
public String getISBN() {
return ISBN;
}
public void setISBN(String ISBN) {
this.ISBN = ISBN;
}
@DynamoDBAttribute(attributeName = "Authors")
public Set getBookAuthors() {
return bookAuthors;
}
public void setBookAuthors(Set bookAuthors) {
this.bookAuthors = bookAuthors;
}
@DynamoDBTypeConverted(converter = DimensionTypeConverter.class)
@DynamoDBAttribute(attributeName = "Dimensions")
public DimensionType getDimensions() {
return dimensionType;
}
@DynamoDBAttribute(attributeName = "Dimensions")
public void setDimensions(DimensionType dimensionType) {
this.dimensionType = dimensionType;
}
@Override
public String toString() {
return "Book [ISBN=" + ISBN + ", bookAuthors=" + bookAuthors + ", dimensionType= "
+ dimensionType.getHeight() + " X " + dimensionType.getLength() + " X "
+ dimensionType.getThickness()
+ ", Id=" + id + ", Title=" + title + "]";
}
}
static public class DimensionType {
private String length;
private String height;
private String thickness;
public String getLength() {
return length;
}
public void setLength(String length) {
this.length = length;
}
public String getHeight() {
return height;
}
public void setHeight(String height) {
this.height = height;
}
public String getThickness() {
return thickness;
}
public void setThickness(String thickness) {
this.thickness = thickness;
}
}
// Converts the complex type DimensionType to a string and vice-versa.
static public class DimensionTypeConverter implements DynamoDBTypeConverter {
@Override
public String convert(DimensionType object) {
DimensionType itemDimensions = (DimensionType) object;
String dimension = null;
try {
if (itemDimensions != null) {
dimension = String.format("%s x %s x %s", itemDimensions.getLength(), itemDimensions.getHeight(),
itemDimensions.getThickness());
}
} catch (Exception e) {
e.printStackTrace();
}
return dimension;
}
@Override
public DimensionType unconvert(String s) {
DimensionType itemDimension = new DimensionType();
try {
if (s != null && s.length() != 0) {
String[] data = s.split("x");
itemDimension.setLength(data[0].trim());
itemDimension.setHeight(data[1].trim());
itemDimension.setThickness(data[2].trim());
}
} catch (Exception e) {
e.printStackTrace();
}
return itemDimension;
}
}
}
```
# Contoh Dynamo DBMapper
BookAuthors { get; set; }
[DynamoDBIgnore]
public string CoverPage { get; set; }
}
```
Dalam contoh sebelumnya, atribut `DynamoDBTable` memetakan kelas `Book` ke tabel `ProductCatalog`.
Model persistensi objek mendukung pemetaan eksplisit dan default antara properti kelas dan atribut tabel.
+ **Pemetaan eksplisit—**Untuk memetakan properti ke kunci primer, Anda harus menggunakan atribut model persistensi objek `DynamoDBHashKey` dan `DynamoDBRangeKey`. Selain itu, untuk atribut kunci nonprimer, jika nama properti di kelas Anda dan atribut tabel terkait yang ingin Anda petakan tidak sama, Anda harus mendefinisikan pemetaan dengan menambahkan atribut `DynamoDBProperty` secara eksplisit.
Dalam contoh sebelumnya, properti `Id` dipetakan ke kunci primer dengan nama yang sama, dan properti `BookAuthors` dipetakan ke atribut `Authors` dalam tabel `ProductCatalog`.
+ **Pemetaan default—**Secara default, model persistensi objek memetakan properti kelas ke atribut dengan nama yang sama dalam tabel.
Dalam contoh sebelumnya, properti `Title` dan `ISBN` dipetakan ke atribut dengan nama yang sama dalam tabel `ProductCatalog`.
Anda tidak perlu memetakan setiap properti kelas tunggal. Anda mengidentifikasi properti ini dengan menambahkan atribut `DynamoDBIgnore`. Ketika Anda menyimpan instans `Book` ke tabel, `DynamoDBContext` tidak menyertakan properti `CoverPage`. Instans tersebut juga tidak mengembalikan properti ini saat Anda mengambil instans buku.
Anda dapat memetakan properti jenis .NET primitif seperti int dan string. Anda juga dapat memetakan setiap jenis data arbitrer selama Anda memberikan konverter yang sesuai untuk memetakan data arbitrer ke salah satu jenis DynamoDB. Untuk mempelajari cara memetakan jenis arbitrer, lihat [Memetakan data arbitrer dengan DynamoDB menggunakan model persistensi objek AWS SDK untuk .NET](DynamoDBContext.ArbitraryDataMapping.md).
Model persistensi objek mendukung penguncian optimis. Selama operasi pembaruan, model ini memastikan bahwa Anda memiliki salinan terbaru dari item yang akan Anda perbarui. Untuk informasi selengkapnya, lihat [Penguncian optimis menggunakan DynamoDB dan model persistensi objek AWS SDK untuk .NET](DynamoDBContext.VersionSupport.md).
Untuk informasi selengkapnya, lihat topik di bawah.
**Topics**
+ [Jenis data yang didukung](#DotNetDynamoDBContext.SupportedTypes)
+ [Atribut DynamoDB dari model persistensi objek.NET](DeclarativeTagsList.md)
+ [DBContext Kelas Dynamo dari model persistensi objek.NET](DotNetDynamoDBContext.md)
+ [Penguncian optimis menggunakan DynamoDB dan model persistensi objek AWS SDK untuk .NET](DynamoDBContext.VersionSupport.md)
+ [Memetakan data arbitrer dengan DynamoDB menggunakan model persistensi objek AWS SDK untuk .NET](DynamoDBContext.ArbitraryDataMapping.md)
## Jenis data yang didukung
BookAuthors { get; set; }
```
`DynamoDBContext` menggunakan informasi pemetaan ini untuk membuat atribut `Authors` saat menyimpan data objek ke tabel yang sesuai.
## Dinamo DBRenamable
(101);
```
**catatan**
Jika objek `Document` mengimplementasikan antarmuka `IEnumerable`, Anda dapat menggunakan metode `FromDocuments` sebagai gantinya. Metode ini memungkinkan Anda melakukan iterasi pada semua instans kelas dalam `Document`.
## FromQuery
/// Shows how to perform high-level CRUD operations on an Amazon DynamoDB
/// table.
///
public class HighLevelItemCrud
{
public static async Task Main()
{
var client = new AmazonDynamoDBClient();
DynamoDBContext context = new DynamoDBContext(client);
await PerformCRUDOperations(context);
}
public static async Task PerformCRUDOperations(IDynamoDBContext context)
{
int bookId = 1001; // Some unique value.
Book myBook = new Book
{
Id = bookId,
Title = "object persistence-AWS SDK for.NET SDK-Book 1001",
Isbn = "111-1111111001",
BookAuthors = new List { "Author 1", "Author 2" },
};
// Save the book to the ProductCatalog table.
await context.SaveAsync(myBook);
// Retrieve the book from the ProductCatalog table.
Book bookRetrieved = await context.LoadAsync(bookId);
// Update some properties.
bookRetrieved.Isbn = "222-2222221001";
// Update existing authors list with the following values.
bookRetrieved.BookAuthors = new List { " Author 1", "Author x" };
await context.SaveAsync(bookRetrieved);
// Retrieve the updated book. This time, add the optional
// ConsistentRead parameter using DynamoDBContextConfig object.
await context.LoadAsync(bookId, new DynamoDBContextConfig
{
ConsistentRead = true,
});
// Delete the book.
await context.DeleteAsync(bookId);
// Try to retrieve deleted book. It should return null.
Book deletedBook = await context.LoadAsync(bookId, new DynamoDBContextConfig
{
ConsistentRead = true,
});
if (deletedBook == null)
{
Console.WriteLine("Book is deleted");
}
}
}
```
## Kueri
latestReplies = context.Query(replyId, QueryOperator.GreaterThan, twoWeeksAgoDate);
```
Tabel ini mengembalikan koleksi objek `Reply`.
Metode `Query` mengembalikan koleksi `IEnumerable` “lazy-loaded”. Metode ini awalnya hanya mengembalikan satu halaman hasil, lalu membuat panggilan layanan untuk halaman berikutnya jika diperlukan. Untuk mendapatkan semua item yang cocok, Anda perlu melakukan iterasi hanya pada `IEnumerable`.
Jika tabel Anda memiliki kunci primer sederhana (kunci partisi), Anda tidak dapat menggunakan metode `Query`. Sebaliknya, Anda dapat menggunakan metode `Load` dan menyediakan kunci partisi untuk mengambil item.
**catatan**
Untuk melakukan operasi ini di latar belakang, gunakan metode `QueryAsync`.
## Save
itemsWithWrongPrice = context.Scan(
new ScanCondition("Price", ScanOperator.LessThan, price),
new ScanCondition("ProductCategory", ScanOperator.Equal, "Book")
);
```
Metode `Scan` mengembalikan koleksi `IEnumerable` “lazy-loaded”. Metode ini awalnya hanya mengembalikan satu halaman hasil, lalu membuat panggilan layanan untuk halaman berikutnya jika diperlukan. Untuk mendapatkan semua item yang cocok, Anda hanya perlu melakukan iterasi pada `IEnumerable`.
Untuk alasan performa, Anda harus mencari tabel dan menghindari pemindaian tabel.
**catatan**
Untuk melakukan operasi ini di latar belakang, gunakan metode `ScanAsync`.
## ToDocument
(101); // Retrieve a forum by primary key.
Document doc = context.ToDocument(forum101);
```
## Menentukan parameter opsional untuk Dynamo DBContext
(productId,new DynamoDBContextConfig{ ConsistentRead = true, SkipVersionCheck = true });
```
Dalam kasus ini, `DynamoDBContext` menyertakan parameter tersebut hanya ketika mengirimkan permintaan `Get`.
# Penguncian optimis menggunakan DynamoDB dan model persistensi objek AWS SDK untuk .NET
BookAuthors { get; set; }
[DynamoDBVersion]
public int? VersionNumber { get; set; }
}
```
**catatan**
Anda dapat menerapkan atribut `DynamoDBVersion` hanya untuk jenis primitif numerik yang dapat di-null-kan (seperti `int?`).
Penguncian optimis memiliki dampak berikut terhadap operasi `DynamoDBContext`:
+ Untuk item baru, `DynamoDBContext` menetapkan nomor versi awal 0. Jika Anda mengambil item yang ada, memperbarui satu atau beberapa properti, dan mencoba untuk menyimpan perubahan, operasi simpan hanya akan berhasil jika nomor versi di sisi klien dan sisi server cocok. `DynamoDBContext` menambahkan nomor versi. Anda tidak perlu mengatur nomor versi.
+ Metode `Delete` menyediakan beban berlebih yang dapat mengambil nilai kunci primer atau objek sebagai parameter, seperti yang ditunjukkan dalam contoh kode C\$1 berikut.
**Example**
```
DynamoDBContext context = new DynamoDBContext(client);
...
// Load a book.
Book book = context.Load(111);
// Do other operations.
// Delete 1 - Pass in the book object.
context.Delete(book);
// Delete 2 - Pass in the Id (primary key)
context.Delete(222);
```
Jika Anda menyediakan objek sebagai parameter, penghapusan berhasil hanya jika versi objek cocok dengan versi item sisi server yang sesuai. Namun, jika Anda memberikan nilai kunci primer sebagai parameter, `DynamoDBContext` tidak mengenali nomor versi apa pun, dan menghapus item tanpa melakukan pemeriksaan versi.
Perhatikan bahwa implementasi internal penguncian optimis dalam kode model persistensi objek menggunakan tindakan API pembaruan bersyarat dan penghapusan bersyarat di DynamoDB.
## Menonaktifkan penguncian optimis
(111);
...
// Delete the book.
context.Delete(book, new DynamoDBContextConfig { SkipVersionCheck = true });
```
# Memetakan data arbitrer dengan DynamoDB menggunakan model persistensi objek AWS SDK untuk .NET
{ "Author 1", "Author 2" },
Dimensions = myBookDimensions
};
context.Save(myBook);
// 2. Retrieve the book.
Book bookRetrieved = context.Load(501);
// 3. Update property (book dimensions).
bookRetrieved.Dimensions.Height += 1;
bookRetrieved.Dimensions.Length += 1;
bookRetrieved.Dimensions.Thickness += 0.2M;
// Update the book.
context.Save(bookRetrieved);
Console.WriteLine("To continue, press Enter");
Console.ReadLine();
}
catch (AmazonDynamoDBException e) { Console.WriteLine(e.Message); }
catch (AmazonServiceException e) { Console.WriteLine(e.Message); }
catch (Exception e) { Console.WriteLine(e.Message); }
}
}
[DynamoDBTable("ProductCatalog")]
public class Book
{
[DynamoDBHashKey] //Partition key
public int Id
{
get; set;
}
[DynamoDBProperty]
public string Title
{
get; set;
}
[DynamoDBProperty]
public string ISBN
{
get; set;
}
// Multi-valued (set type) attribute.
[DynamoDBProperty("Authors")]
public List BookAuthors
{
get; set;
}
// Arbitrary type, with a converter to map it to DynamoDB type.
[DynamoDBProperty(typeof(DimensionTypeConverter))]
public DimensionType Dimensions
{
get; set;
}
}
public class DimensionType
{
public decimal Length
{
get; set;
}
public decimal Height
{
get; set;
}
public decimal Thickness
{
get; set;
}
}
// Converts the complex type DimensionType to string and vice-versa.
public class DimensionTypeConverter : IPropertyConverter
{
public DynamoDBEntry ToEntry(object value)
{
DimensionType bookDimensions = value as DimensionType;
if (bookDimensions == null) throw new ArgumentOutOfRangeException();
string data = string.Format("{1}{0}{2}{0}{3}", " x ",
bookDimensions.Length, bookDimensions.Height, bookDimensions.Thickness);
DynamoDBEntry entry = new Primitive
{
Value = data
};
return entry;
}
public object FromEntry(DynamoDBEntry entry)
{
Primitive primitive = entry as Primitive;
if (primitive == null || !(primitive.Value is String) || string.IsNullOrEmpty((string)primitive.Value))
throw new ArgumentOutOfRangeException();
string[] data = ((string)(primitive.Value)).Split(new string[] { " x " }, StringSplitOptions.None);
if (data.Length != 3) throw new ArgumentOutOfRangeException();
DimensionType complexData = new DimensionType
{
Length = Convert.ToDecimal(data[0]),
Height = Convert.ToDecimal(data[1]),
Thickness = Convert.ToDecimal(data[2])
};
return complexData;
}
}
}
```