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.
# Higher-Level-Programmierschnittstellen für 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; }
}
```
Im vorherigen Code weist die Anmerkung `@DynamoDBTable` die Klasse `CatalogItem` der Tabelle `ProductCatalog` zu. Sie können einzelne Klassen-Instances als Elemente in der Tabelle speichern. Die Anmerkung `@DynamoDBHashKey` weist die Eigenschaft `Id` dem Primärschlüssel zu.
Standardmäßig sind die Klasseneigenschaften denselben Attributnamen in der Tabelle zugeordnet. Die Eigenschaften `Title` und `ISBN` sind den gleichen Attributnamen in der Tabelle zugeordnet.
Die `@DynamoDBAttribute`-Anmerkung ist optional, wenn der Name des DynamoDB-Attributs dem Namen der in der Klasse angegebenen Eigenschaft entspricht. Wenn sich die Namen unterscheiden, verwenden Sie diese Anmerkung mit dem Parameter `attributeName`, um anzugeben, mit welchem DynamoDB-Attribut diese Eigenschaft übereinstimmt.
Im vorangegangenen Beispiel wird jeder Eigenschaft die Annotation `@DynamoDBAttribute` hinzugefügt, um sicherzustellen, dass Eigenschaftsnamen genau den Tabellen entsprechen, die in einem vorherigen Schritt erstellt wurden und um die Attributnamen, die in anderen Codebeispielen in diesem Handbuch verwendet werden, einzuhalten.
Ihre Klassendefinition kann Eigenschaften besitzen, die keinen Attributen in der Tabelle zugeordnet sind. Sie erkennen diese Eigenschaften, indem Sie die `@DynamoDBIgnore`-Anmerkung hinzufügen. Im vorangegangenen Beispiel ist die `SomeProp`-Eigenschaft mit der `@DynamoDBIgnore`-Anmerkung gekennzeichnet. Wenn Sie eine `CatalogItem`-Instance in die Tabelle hochladen, enthält Ihre `DynamoDBMapper`-Instance die Eigenschaft `SomeProp` nicht. Darüber hinaus gibt der Mapper dieses Attribut nicht zurück, wenn Sie ein Element aus der Tabelle abrufen.
Nachdem Sie die Mappingklasse definierthaben, können Sie `DynamoDBMapper`-Methoden verwenden, um eine Instance dieser Klasse zu einem entsprechenden Element in der Tabelle `Catalog` zu schreiben. Das folgende Codebeispiel zeigt diese Technik.
```
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);
```
Im folgenden Codebeispiel wird gezeigt, wie Sie das Element abrufen und auf einige seiner Attribute zugreifen.
```
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` ermöglicht ein intuitives und natürliches Arbeiten mit DynamoDB-Daten in Java. Er bietet auch verschiedene integrierte Funktionen wie optimistische Sperre, ACID-Transaktionen, automatisch generierte Partitions- und Sortierschlüsselwerte sowie Objektversionierung.
# Dynamo-Klasse 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);
```
Die Abfrage gibt eine Sammlung von `Reply`-Objekten zurück.
Die `query`-Methode gibt standardmäßig eine "lazy-loaded"-Sammlung zurück. Sie gibt anfänglich ausschließlich eine Ergebnisseite zurück und führt dann bei Bedarf einen Dienstaufruf für die nächste Seite durch. Um alle übereinstimmenden Elemente zu erhalten, müssen Sie die Sammlung `latestReplies` durchlaufen.
Beachten Sie, dass beim Aufrufen der `size()`-Methode für die Sammlung jedes Ergebnis geladen wird, um eine genaue Zählung zu liefern. Dies kann dazu führen, dass viel bereitgestellter Durchsatz verbraucht wird, und bei einer sehr großen Tabelle könnte sogar der gesamte Speicher in Ihrer JVM ausgeschöpft werden.
Für eine Indexabfrage müssen Sie zuerst den Index als eine Mapper-Klasse modellieren. *Angenommen, die `Reply` Tabelle hat einen globalen sekundären Index namens -Message-Index. PostedBy* Der Partitionsschlüssel für diesen Index ist `PostedBy` und der Sortierschlüssel ist `Message`. Die Klassendefinition für ein Element im Index würde wie folgt aussehen.
```
@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.
}
```
Die Anmerkung `@DynamoDBTable` gibt an, dass dieser Index mit der Tabelle `Reply` verknüpft ist. Die `@DynamoDBIndexHashKey` Anmerkung bezeichnet den Partitionsschlüssel (*PostedBy*) des Indexes und `@DynamoDBIndexRangeKey` den Sortierschlüssel (*Message*) des Indexes.
Sie können jetzt `DynamoDBMapper` nutzen, um den Index abzufragen, der eine Teilmenge der Nachrichten, die von einem bestimmten Benutzer gepostet wurden, abruft. Sie müssen den Indexnamen nicht angeben, wenn Sie keine widersprüchlichen Zuordnungen zwischen Tabellen und Indizes haben und die Zuordnungen bereits im Mapper vorgenommen wurden. Der Mapper leitet anhand des Primärschlüssels und des Sortierschlüssels ab. Der folgende Code fragt den globalen sekundären Index ab. Da globale sekundäre Indizes Eventually Consistent-Lesevorgänge, jedoch keine Strongly Consistent-Lesevorgänge unterstützen, müssen Sie `withConsistentRead(false)` angeben.
```
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);
```
Die Abfrage gibt eine Sammlung von `PostedByMessage`-Objekten zurück.
## 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);
```
Die `scan`-Methode gibt standardmäßig eine "lazy-loaded"-Sammlung zurück. Sie gibt anfänglich ausschließlich eine Ergebnisseite zurück und führt dann bei Bedarf einen Dienstaufruf für die nächste Seite durch. Um alle übereinstimmenden Elemente zu erhalten, müssen Sie die Sammlung `replies` durchlaufen.
Beachten Sie, dass beim Aufrufen der `size()`-Methode für die Sammlung jedes Ergebnis geladen wird, um eine genaue Zählung zu liefern. Dies kann dazu führen, dass viel bereitgestellter Durchsatz verbraucht wird, und bei einer sehr großen Tabelle könnte sogar der gesamte Speicher in Ihrer JVM ausgeschöpft werden.
Um einen Index zu scannen, müssen Sie zuerst den Index als eine Mapper-Klasse modellieren. Angenommen, die `Reply`-Tabelle hat einen globalen sekundären Index namens `PostedBy-Message-Index`. Der Partitionsschlüssel für diesen Index ist `PostedBy` und der Sortierschlüssel ist `Message`. Im Abschnitt [query](#DynamoDBMapper.Methods.query) wird eine Mapper-Klasse für diesen Index gezeigt. Sie verwendet die Anmerkungen `@DynamoDBIndexHashKey` und `@DynamoDBIndexRangeKey`, um den Partitions- und Sortierschlüssel des Index anzugeben.
Im folgenden Codebeispiel wird `PostedBy-Message-Index` gescannt. Er verwendet keinen Scan-Filter, sodass alle Elemente im Index an Sie zurückgegeben werden.
```
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; }
```
Der `DynamoDBMapper` verwendet `Authors` als Attributnamen bei der Speicherung des Objekts in die Tabelle.
## Dynamo 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;}
}
```
Sie können die `@DynamoDBVersionAttribute`-Anmerkung auf löschbare Typen anwenden, die durch primitive Wrapper-Klassen bereitgestellt wurden, die wiederum einen löschbaren Typ wie `Long` und `Integer` bereitstellen.
Die optimistische Sperre hat folgende Auswirkungen auf diese `DynamoDBMapper`-Methoden:
+ `save` – für ein neues Element weist der `DynamoDBMapper` eine erste Versionsnummer 1 zu. Wenn Sie ein Element abrufen, eine oder mehrere seiner Eigenschaften aktualisieren und versuchen, die Änderungen zu speichern, ist die Speicheroperation nur dann erfolgreich, wenn die clientseitige und die serverseitige Versionsnummer übereinstimmen. Der `DynamoDBMapper` erhöht die Versionsnummer automatisch.
+ `delete` – die `delete`-Methode übernimmt ein Objekt als einen Parameter und der `DynamoDBMapper` führt einen Versionscheck durch, bevor er das Element löscht. Der Versionscheck kann deaktiviert werden, wenn `DynamoDBMapperConfig.SaveBehavior.CLOBBER` in der Anforderung angegeben wird.
Die interne Implementierung der optimistischen Sperre im `DynamoDBMapper` nutzt die von DynamoDB bereitgestellte Unterstützung für bedingtes Aktualisieren und bedingtes Löschen.
+ `transactionWrite` —
+ `Put` – für ein neues Element weist der `DynamoDBMapper` eine erste Versionsnummer 1 zu. Wenn Sie ein Element abrufen, eine oder mehrere seiner Eigenschaften aktualisieren und versuchen, die Änderungen zu speichern, ist die Put-Operation nur dann erfolgreich, wenn die clientseitige und die serverseitige Versionsnummer übereinstimmen. Der `DynamoDBMapper` erhöht die Versionsnummer automatisch.
+ `Update` – für ein neues Element weist der `DynamoDBMapper` eine erste Versionsnummer 1 zu. Wenn Sie ein Element abrufen, eine oder mehrere seiner Eigenschaften aktualisieren und versuchen, die Änderungen zu speichern, ist die Update-Operation nur dann erfolgreich, wenn die clientseitige und die serverseitige Versionsnummer übereinstimmen. Der `DynamoDBMapper` erhöht die Versionsnummer automatisch.
+ `Delete` – `DynamoDBMapper` führt eine Versionsprüfung durch, bevor er das Element löscht. Die Lösch-Operation ist nur dann erfolgreich, wenn die Versionsnummern auf Clientseite und auf Serverseite übereinstimmen.
+ `ConditionCheck` – die `@DynamoDBVersionAttribute`-Anmerkung wird für `ConditionCheck`-Operationen nicht unterstützt. Ein SdkClientException wird ausgelöst, wenn ein `ConditionCheck` Element mit einer Anmerkung versehen ist. `@DynamoDBVersionAttribute`
## Deaktivieren der optimistischen Sperre
(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;
}
}
}
```
# Beispiele für DynamoDBMapper
BookAuthors { get; set; }
[DynamoDBIgnore]
public string CoverPage { get; set; }
}
```
Im vorherigen Beispiel ordnet das Attribut `DynamoDBTable` die Klasse `Book` der Tabelle `ProductCatalog` zu.
Das Object Persistence-Modell unterstützt die explizite und das Standardmapping zwischen Klasseneigenschaften und Tabellenattributen.
+ **Explizites Mapping – **Um eine Eigenschaft einem Primärschlüssel zuzuordnen, müssen Sie die `DynamoDBHashKey`- und `DynamoDBRangeKey`-Attribute des „Object-Persistence“-Modells verwenden. Außerdem gilt für andere als Primärschlüsselattribute, dass Sie das Mapping durch explizites Hinzufügen des Attributs `DynamoDBProperty` definieren müssen, wenn der Name einer Eigenschaft in Ihrer Klasse und des Tabellenattributs, dem Sie diese zuordnen möchten, nicht identisch sind.
Im vorherigen Beispiel werden die Eigenschaft `Id` dem Primärschlüssel mit dem gleichen Namen und die Eigenschaft `BookAuthors` dem Attribut `Authors` in der Tabelle `ProductCatalog` zugeordnet.
+ **Standard-Mapping – **Standardmäßig ordnet das „Object Persistence“-Modell die Klasseneigenschaften den Attributen mit identischem Namen in der Tabelle zu.
Im vorherigen Beispiel werden die Eigenschaften `Title` und `ISBN` den Attributen mit den gleichen Namen in der Tabelle `ProductCatalog` zugeordnet.
Sie müssen nicht jede einzelne Klasseneigenschaft zuordnen. Sie erkennen diese Eigenschaften, indem Sie das `DynamoDBIgnore`-Attribut hinzufügen. Wenn Sie eine `Book`-Instance in die Tabelle hochladen, enthält der `DynamoDBContext` nicht die `CoverPage`-Eigenschaft. Diese Eigenschaft wird auch nicht zurückgegeben, wenn Sie die Book-Instance abrufen.
Sie können Eigenschaften von primitiven .NET-Typen wie „int“ und „string“ zuweisen. Sie können auch beliebige Datentypen zuordnen, solange Sie einen geeigneten Konverter bereitstellen, um diese Datentypen einem DynamoDB-Datentyp zuzuordnen. Weitere Informationen zum Mapping beliebiger Datentypen finden Sie unter [Zuordnen beliebiger Daten mit DynamoDB mithilfe des AWS SDK für .NET Objektpersistenzmodells](DynamoDBContext.ArbitraryDataMapping.md).
Das Object Persistence-Modell unterstützt die optimistische Sperre. Während einer Aktualisierung stellt diese Funktion sicher, dass Sie über die neueste Kopie des zu aktualisierenden Elements verfügen. Weitere Informationen finden Sie unter [Optimistisches Sperren mit DynamoDB und dem AWS SDK für .NET Objektpersistenzmodell](DynamoDBContext.VersionSupport.md).
Weitere Informationen finden Sie in den folgenden Themen.
**Topics**
+ [Unterstützte Datentypen](#DotNetDynamoDBContext.SupportedTypes)
+ [DynamoDB-Attribute aus dem Object Persistence-Modell von .NET](DeclarativeTagsList.md)
+ [DBContext Dynamo-Klasse aus dem .NET-Objektpersistenzmodell](DotNetDynamoDBContext.md)
+ [Optimistisches Sperren mit DynamoDB und dem AWS SDK für .NET Objektpersistenzmodell](DynamoDBContext.VersionSupport.md)
+ [Zuordnen beliebiger Daten mit DynamoDB mithilfe des AWS SDK für .NET Objektpersistenzmodells](DynamoDBContext.ArbitraryDataMapping.md)
## Unterstützte Datentypen
BookAuthors { get; set; }
```
`DynamoDBContext` verwendet diese Mappinginformationen, um beim Speichern von Objektdaten zur entsprechenden Tabelle das Attribut `Authors` zu erstellen.
## Dynamo DBRenamable
(101);
```
**Anmerkung**
Wenn das `Document`-Objekt die `IEnumerable`-Schnittstelle implementiert, können Sie stattdessen die `FromDocuments`-Methode nutzen. Auf diese Weise können Sie alle Klassen-Instances im `Document` durchlaufen.
## 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");
}
}
}
```
## Query
latestReplies = context.Query(replyId, QueryOperator.GreaterThan, twoWeeksAgoDate);
```
Dies gibt eine Sammlung von `Reply`-Objekten zurück.
Die Methode `Query` gibt standardmäßig eine „lazy-loaded“ `IEnumerable`-Sammlung zurück. Sie gibt anfänglich ausschließlich eine Ergebnisseite zurück und führt dann bei Bedarf einen Dienstaufruf für die nächste Seite durch. Um alle übereinstimmenden Elemente zu erhalten, müssen Sie lediglich die `IEnumerable`-Sammlung durchlaufen.
Wenn die Tabelle über einen einfachen Primärschlüssel (Partitionsschlüssel) verfügt, können Sie die Methode `Query` nicht verwenden. Stattdessen können Sie die Methode `Load` verwenden und den Partitionsschlüssel bereitstellen, um das Element abzurufen.
**Anmerkung**
Um diese Operation im Hintergrund auszuführen, nutzen Sie stattdessen die `QueryAsync`-Methode.
## Save
itemsWithWrongPrice = context.Scan(
new ScanCondition("Price", ScanOperator.LessThan, price),
new ScanCondition("ProductCategory", ScanOperator.Equal, "Book")
);
```
Die Methode `Scan` gibt standardmäßig eine „lazy-loaded“ `IEnumerable`-Sammlung zurück. Sie gibt anfänglich ausschließlich eine Ergebnisseite zurück und führt dann bei Bedarf einen Dienstaufruf für die nächste Seite durch. Um alle übereinstimmenden Elemente zu erhalten, müssen Sie lediglich die `IEnumerable`-Sammlung durchlaufen.
Aus Leistungsgründen sollten Sie Ihre Tabellen abfragen und einen Tabellen-Scan vermeiden.
**Anmerkung**
Um diese Operation im Hintergrund auszuführen, nutzen Sie stattdessen die `ScanAsync`-Methode.
## ToDocument
(101); // Retrieve a forum by primary key.
Document doc = context.ToDocument(forum101);
```
## Optionale Parameter für Dynamo angeben DBContext
(productId,new DynamoDBContextConfig{ ConsistentRead = true, SkipVersionCheck = true });
```
In diesem Fall berücksichtigt `DynamoDBContext` diese Parameter ausschließlich beim Senden der `Get`-Anforderung.
# Optimistisches Sperren mit DynamoDB und dem AWS SDK für .NET Objektpersistenzmodell
BookAuthors { get; set; }
[DynamoDBVersion]
public int? VersionNumber { get; set; }
}
```
**Anmerkung**
Sie können das `DynamoDBVersion`-Attribut ausschließlich auf einen löschbaren numerischen primitiven Typen anwenden (z. B. `int?`).
Die optimistische Sperre hat folgende Auswirkungen auf diese `DynamoDBContext`-Operationen:
+ Für ein neues Element weist `DynamoDBContext` die Erstversionsnummer 0 zu. Wenn Sie ein vorhandenes Element abrufen, eine oder mehrere von dessen Eigenschaften aktualisieren und versuchen, die Änderungen zu speichern, wird die Speicheroperation nur dann erfolgreich ausgeführt, wenn die client- und serverseitige Versionsnummer übereinstimmen. `DynamoDBContext` erhöht die Versionsnummer inkrementell. Sie müssen die Versionsnummer nicht festlegen.
+ Die Methode `Delete` stellt Überladungen bereit, die entweder einen Primärschlüsselwert oder ein Objekt als Parameter aufnehmen können, wie im folgenden C\$1-Codebeispiel gezeigt.
**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);
```
Wenn Sie ein Objekt als Parameter bereitstellen, ist der Löschvorgang nur dann erfolgreich, wenn die Objektversion mit der entsprechenden serverseitigen Elementversion übereinstimmt. Wenn Sie jedoch einen Primärschlüsselwert als Parameter bereitstellen, erkennt `DynamoDBContext` keine Versionsnummern und löscht das Element, ohne die Version zu prüfen.
Beachten Sie, dass die interne Implementierung von optimistischen Sperren in dem Code des Object-Persistence-Modells bedingte Aktualisierungen und bedingte Löschungs-API-Aktionen in DynamoDB verwendet.
## Deaktivieren der optimistischen Sperre
(111);
...
// Delete the book.
context.Delete(book, new DynamoDBContextConfig { SkipVersionCheck = true });
```
# Zuordnen beliebiger Daten mit DynamoDB mithilfe des AWS SDK für .NET Objektpersistenzmodells
{ "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;
}
}
}
```