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.
# Amazon – DynamoDB
## Was ist Amazon DynamoDB?
[Amazon DynamoDB](https://aws.amazon.com/dynamodb/) ist ein schneller, hochgradig skalierbarer Service für nicht relationale Datenbanken. DynamoDBMit werden Einschränkungen der Datenspeicherungsskalierbarkeit eliminiert, die Latenz niedrig gehalten und die Leistung ist vorhersehbar.
## Die wichtigsten Konzepte
Die DynamoDB Datenmodellkonzepte umfassen Tabellen, Elemente und Attribute.
### Tables
In Amazon ist DynamoDBeine Datenbank eine Sammlung von Tabellen. Eine Tabelle ist eine Sammlung von Elementen und jedes Element wiederum eine Sammlung von Attributen.
In einer relationalen Datenbank hat eine Tabelle ein vordefiniertes Schema, z. B. Tabellenname, Primärschlüssel, Liste der Spaltennamen sowie Datentypen der Spalten. Alle Datensätze in der Tabelle müssen über dieselben Spalten verfügen. Im Gegensatz dazu erfordert DynamoDB nur, dass eine Tabelle über einen Primärschlüssel verfügt, aber nicht alle Attributnamen und Datentypen im Voraus definieren muss.
Weitere Informationen zum Arbeiten mit Tabellen finden Sie unter [Arbeiten mit Tabellen in DynamoDB ](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.html).
### Elemente und Attribute
Einzelne Elemente in einer DynamoDB Tabelle können eine beliebige Anzahl von Attributen haben, obwohl die Elementgröße auf 400 KB beschränkt ist. Die Elementgröße wird gebildet aus der Länge der Attributnamen und -werte (Binär- und UTF-8-Längen).
Jedes Attribut in einem Element ist ein Name-Wert-Paar. Ein Attribut kann einen Wert oder mehrere Werten aufweisen. So kann ein Buchelement beispielsweise Attribute für Titel und Autor aufweisen. Jedes Buch hat einen Titel, kann jedoch mehrere Autoren haben. Das Attribut für mehrere Werte ist eine Gruppe, Duplikatwerte sind nicht zulässig.
Nehmen wir als Beispiel, einen Katalog von Produkten in zu DynamoDBspeichern. Sie können eine Tabelle erstellen, ProductCatalog, mit dem ID-Attribut als Primärschlüssel. Der Primärschlüssel identifiziert jedes Element eindeutig, es können also nicht zwei Produkte in der Tabelle dieselbe ID aufweisen.
Weitere Informationen zum Arbeiten mit Elementen finden Sie unter [Arbeiten mit Elementen im DynamoDB ](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html).
### Datentypen
Amazon DynamoDB unterstützt die folgenden Datentypen:
+ **Skalare Typen**: Number, String, Binary, Boolean und Null.
+ **Typen für mehrere Werte**: String Set, Number Set und Binary Set.
+ **Dokumenttypen**: List und Map.
Weitere Informationen zu skalaren Datentypen, Datentypen mit mehreren Werten und Dokumentdatentypen finden Sie unter [DynamoDB -](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataModel.html#DataModel.DataTypes)Datentypen.
### Primärschlüssel
Wenn Sie eine Tabelle erstellen, müssen Sie außer dem Tabellennamen auch den Primärschlüssel der Tabelle angeben. Der Primärschlüssel identifiziert jedes Element in der Tabelle eindeutig, es gibt also nicht zwei Elemente mit identischem Schlüsselwert. DynamoDB unterstützt die folgenden zwei Typen von Primärschlüsseln:
+ **Hash-Schlüssel**: Der Primärschlüssel besteht aus einem Attribut, einem Hash-Attribut. DynamoDB erstellt einen ungeordneten Hash-Index für dieses Primärschlüsselattribut. Jedes Element in der Tabelle wird eindeutig anhand seines Hash-Schlüsselwerts identifiziert.
+ **Hash- und Bereichsschlüssel**: Der Primärschlüssel besteht aus zwei Attributen. Das erste Attribut ist das Hash-Attribut, das zweite das Bereichsattribut. DynamoDB erstellt einen ungeordneten Hash-Index auf dem Hash-Primärschlüsselattribut und einen sortierten Bereichsindex auf dem Bereichs-Primärschlüsselattribut. Jedes Element in der Tabelle wird durch die Kombination der Hash- und Bereichsschlüsselwerte eindeutig identifiziert. Zwei Elemente können denselben Hash-Schlüsselwert, müssen aber unterschiedliche Bereichsschlüsselwerte aufweisen.
### Sekundäre Indizes
Wenn Sie eine Tabelle mit einem Hash- und Bereichsschlüssel erstellen, können Sie optional einzelne oder mehrere Sekundärindizes für die betreffende Tabelle definieren. Ein Sekundärindex ermöglicht – ergänzend zu Abfragen über den Primärschlüssel – das Abfragen der Daten in der Tabelle über einen alternativen Schlüssel.
DynamoDB unterstützt zwei Arten von sekundären Indizes: lokale sekundäre Indizes und globale sekundäre Indizes.
+ **Lokaler Sekundärindex**: Ein Index mit demselben Hash-Schlüssel wie die Tabelle, jedoch einem anderen Bereichsschlüssel.
+ **Globaler Sekundärindex**: Ein Index mit einem Hash- und Bereichsschlüssel, der sich von den Schlüsseln der Tabelle unterscheiden kann.
Sie können bis zu 5 globale Sekundärindizes und 5 lokale Sekundärindizes pro Tabelle definieren. Weitere Informationen finden Sie unter [Verbessern des Datenzugriffs mit sekundären Indizes in DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/SecondaryIndexes.html) im -DynamoDBEntwicklerhandbuch.
### Query und Scan
Zusätzlich zur Verwendung von Primärschlüsseln für den Zugriff auf Elemente bietet Amazon DynamoDB auch zwei APIs für die Datensuche: Query und Scan. Wir empfehlen, dass Sie [Richtlinien für Abfragen und](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScanGuidelines.html) Scans im DynamoDB -Entwicklerhandbuch lesen, um sich mit einigen bewährten Methoden vertraut zu machen.
#### Query
Eine Query-Operation sucht Elemente ausschließlich unter Verwendung von Primärschlüssel-Attributwerten in einer Tabelle oder einem Sekundärindex. Sie müssen einen Hash-Schlüsselattributnamen und einen Wert angeben, der gesucht werden soll. Sie können optional den Namen und den Wert eines Bereichsschlüsselattributs angeben und einen Vergleichsoperator verwenden, um die Suchergebnisse zu verfeinern.
Beispielabfragen finden Sie unter:
+ [Verwenden des Document-Modells](dynamodb-integration-docmodel.md)
+ [Verwenden des Object Persistence-Modells](dynamodb-integration-objectpersistencemodel.md)
+ [Verwenden des DynamoDB Service Levels APIs](dynamodb-integration-lowlevelapi.md)
Weitere Informationen zu Query finden Sie unter [Query](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScan.html#QueryAndScan.Query) im -DynamoDBEntwicklerhandbuch.
#### Scan
Eine Scan-Operation liest jedes Element in einer Tabelle oder einem Sekundärindex. Standardmäßig gibt eine Scan-Operation für jedes Element in der Tabelle oder im Index alle Datenattribute zurück. Sie können den ProjectionExpression Parameter verwenden, sodass Scan nur einige der Attribute und nicht alle zurückgibt.
Beispielscans finden Sie unter:
+ [Verwenden des Document-Modells](dynamodb-integration-docmodel.md)
+ [Verwenden des Object Persistence-Modells](dynamodb-integration-objectpersistencemodel.md)
+ [Verwenden des DynamoDB Service Levels APIs](dynamodb-integration-lowlevelapi.md)
Weitere Informationen zu Scan finden Sie unter [Scan](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScan.html#QueryAndScan.Scan) im -DynamoDBEntwicklerhandbuch.
## Projekteinrichtung
### Prerequisites
Um DynamoDB in Ihrer Anwendung zu verwenden, müssen Sie das SDK zu Ihrem Projekt hinzufügen. Befolgen Sie zu diesem Zweck die Anweisungen unter [Einrichten von AWS Mobile SDK for .NET and Xamarin](setup.md).
### Erstellen einer DynamoDB Tabelle
Gehen Sie zum Erstellen einer Tabelle zur -[DynamoDBKonsole](https://console.aws.amazon.com/dynamodb/home) und führen Sie die folgenden Schritte aus:
1. Klicken Sie auf **Create Table**.
1. Geben Sie den Namen der Tabelle ein.
1. Wählen Sie **Hash** als Primärschlüsseltyp aus.
1. Wählen Sie einen Typ und geben Sie einen Wert für den Hash-Attributnamen ein. Klicken Sie auf **Weiter**.
1. Wenn Sie auf der Seite **Add Indexes** globale sekundäre Indizes verwenden möchten, legen Sie **Index Type** auf „Global Secondary Index“ fest und geben Sie unter **Index Hash Key **einen Wert für den sekundären Index ein. So können Sie Primärindex und Sekundärindex abfragen und scannen. Klicken Sie auf **Add Index To Table (Index zur Tabelle hinzufügen)** und dann auf **Continue (Weiter)**. Klicken Sie auf **Continue (Weiter)**., wenn Sie keine globalen Sekundärindizes verwenden wollen.
1. Stellen Sie für Lese- und Schreibkapazität die gewünschten Größen ein. Weitere Informationen zum Konfigurieren der Kapazität finden Sie unter [Bereitgestellter Durchsatz in Amazon DynamoDB ](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ProvisionedThroughputIntro.html). Klicken Sie auf **Continue (**Weiter).
1. Geben Sie im nächsten Bildschirm eine Benachrichtigungs-E-Mail ein, um ggf. Durchsatzalarme zu erstellen. Klicken Sie auf **Weiter**.
1. Klicken Sie auf der Übersichtsseite auf **Create (Erstellen)**. DynamoDB erstellt Ihre Datenbank.
### Festlegen von -Berechtigungen für DynamoDB
Um DynamoDB in einer Anwendung zu verwenden, müssen Sie die richtigen Berechtigungen festlegen. Mit der folgenden IAM-Richtlinie kann der Benutzer Elemente in einer bestimmten DynamoDB Tabelle, die durch den [ARN ](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)identifiziert wird, löschen, abrufen, ablegen, abfragen, scannen und aktualisieren:
```
{
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:DeleteItem",
"dynamodb:GetItem",
"dynamodb:PutItem",
"dynamodb:Query",
"dynamodb:Scan",
"dynamodb:UpdateItem"
],
"Resource": "arn:aws:dynamodb:us-west-2:123456789012:table/MyTable"
}
]
}
```
Sie können Richtlinien in der [IAM-Konsole](https://console.aws.amazon.com/iam/). modifizieren. Sie sollten zulässige Aktionen basierend auf den Anforderungen der App hinzufügen oder entfernen.
Weitere Informationen zu IAM-Richtlinien erhalten Sie unter [Using IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/IAM_Introduction.html).
Weitere Informationen zu DynamoDB-spezifischen Richtlinien finden Sie unter [Using IAM to Control Access to DynamoDB Resources](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/UsingIAMWithDDB.html) im -DynamoDBEntwicklerhandbuch.
## Integrieren von DynamoDB in Ihre Anwendung
Das AWS Mobile SDK for .NET and Xamarin bietet eine allgemeine Bibliothek für die Arbeit mit DynamoDB. Sie können auch Anforderungen direkt an die DynamoDB Low-Level-API stellen, aber für die meisten Anwendungsfälle wird die High-Level-Bibliothek empfohlen. Der AmazonDynamoDBClient ist ein besonders nützlicher Teil der High-Level-Bibliothek. Mit dieser Klasse können Sie verschiedene CRUD-Operationen (Erstellen, Lesen, Aktualisieren, Löschen) sowie Abfragen ausführen.
Das AWS Mobile SDK for .NET and Xamarin ermöglicht es Ihnen, Aufrufe mit APIs über das AWS SDK for .NET zu tätigen, um mit zu DynamoDBarbeiten. Alle -APIsDateien sind in der Datei AWSSDK.dll verfügbar. Weitere Informationen zum Herunterladen von AWS SDK for .NET erhalten Sie unter [AWS SDK for .NET](https://aws.amazon.com/sdk-for-net/).
Es gibt drei Möglichkeiten, mit DynamoDB in Ihrer Xamarin-Anwendung zu interagieren:
+ ** **Dokumentmodell: Diese API stellt Wrapper-Klassen für die DyanmoDB Low-Level-API bereit, um Ihre Programmieraufgaben weiter zu vereinfachen. Die wichtigsten Wrapper-Klassen sind Table und Document. Sie können das Dokumentmodell für Datenoperationen wie das Erstellen, Abrufen, Aktualisieren und Löschen von Elementen verwenden. Die API ist im Namespace Amazon.DynamoDB.DocumentModel verfügbar.
+ **Object **Persistence-Modell: Mit der Object Persistence-API können Sie den DynamoDB -Tabellen clientseitige Klassen zuordnen. Die einzelnen Objekt-Instances werden anschließend einem Element in den entsprechenden Tabellen zugeordnet. Die DynamoDBContext -Klasse in dieser API bietet Methoden, mit denen Sie clientseitige Objekte in einer Tabelle speichern, Elemente als -Objekte abrufen und Abfragen und Scans durchführen können. Sie können das Object Persistence-Modell für Datenoperationen wie das Erstellen, Abrufen, Aktualisieren und Löschen von Elementen verwenden. Sie müssen zunächst die Tabellen mit der Service-Client-API erstellen und dann das Objektpersistenzmodell verwenden, um die Klassen den Tabellen zuzuordnen. Die API ist im Namespace Amazon.DynamoDB.DataModel verfügbar.
+ ** **Service-Client-API: Dies ist die API auf Protokollebene, die der DynamoDB API eng zugeordnet ist. Sie können diese Low-Level-API für alle Tabellen- und Elementoperationen wie das Erstellen, Aktualisieren und Löschen von Tabellen und Elementen verwenden. Sie können Tabellen außerdem abfragen und scannen. Diese API ist im Namespace Amazon.DynamoDB namespace verfügbar.
Diese drei Modelle werden in den folgenden Themen ausführlich behandelt:
**Topics**
# Verwenden des Document-Modells
Das Dokumentmodell stellt Wrapper-Klassen für die .NET-Low-Level-API bereit. Die wichtigsten Wrapper-Klassen sind Table und Document. Sie können das Dokumentmodell verwenden, um Elemente zu erstellen, abzurufen, zu aktualisieren und zu löschen. Zum Erstellen, Aktualisieren und Löschen von Tabellen müssen Sie die Low-Level-API verwenden. Anweisungen zur Verwendung der Low-Level-API finden Sie unter [Verwenden des DynamoDB Service APIsLevels ](dynamodb-integration-lowlevelapi.md). Die Low-Level-API ist im Namespace DynamoDB.DocumentModel verfügbar.
Weitere Informationen zum Dokumentmodell erhalten Sie unter [.NET: Dokumentmodell](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DotNetSDKMidLevel.html).
## Erstellen eines DynamoDB Clients
So erstellen Sie einen DynamoDB Client:
```
var client = new AmazonDynamoDBClient(credentials,region);
DynamoDBContext context = new DynamoDBContext(client);
```
## CRUD-Operationen
### Speichern eines Elements
Erstellen Sie ein Element wie folgt:
```
Table table = Table.LoadTable(client, "Books");
id = Guid.NewGuid().ToString();
var books = new Document();
books["Id"] = id;
books["Author"] = "Mark Twain";
books["Title"] = "Adventures of Huckleberry Finn";
books["ISBN"] = "112-111111";
books["Price"] = "10";
```
Speichern eines Elements in einer DynamoDB Tabelle:
```
var book = await table.PutItemAsync(books);
```
### Abrufen eines Elements
Rufen Sie ein Element wie folgt ab:
```
public async Task GetItemAsync(AWSCredentials credentials, RegionEndpoint region)
{
var client = new AmazonDynamoDBClient(credentials, region);
Table books = Table.LoadTable(client, "Books");
var book = await books.GetItemAsync(id);
}
```
### Aktualisieren eines Elements
Aktualisieren Sie ein Element wie folgt:
```
public async Task UpdateItemAttributesAsync(AWSCredentials credentials, RegionEndpoint region)
{
var book = new Document();
book["Id"] = id;
book["PageCount"] = "200";
var client = new AmazonDynamoDBClient(credentials, region);
Table books = Table.LoadTable(client, "Books");
Document updatedBook = await books.UpdateItemAsync(book);
}
```
Aktualisieren Sie ein Element wie folgt bedingungsabhängig:
```
public async Task UpdateItemConditionallyAsync(AWSCredentials credentials, RegionEndpoint region) {
var book = new Document();
book["Id"] = id;
book["Price"] = "30";
// For conditional price update, creating a condition expression.
Expression expr = new Expression();
expr.ExpressionStatement = "Price = :val";
expr.ExpressionAttributeValues[":val"] = 10.00;
var client = new AmazonDynamoDBClient(credentials, region);
Table books = Table.LoadTable(client, "Books");
Document updatedBook = await books.UpdateItemAsync(book);
}
```
### Löschen eines Elements
So löschen Sie einen Artikel:
```
public async Task DeleteItemAsync(AWSCredentials credentials, RegionEndpoint region)
{
var client = new AmazonDynamoDBClient(credentials, region);
Table books = Table.LoadTable(client, "Books");
await books.DeleteItemAsync(id);
}
```
### Query und Scan
Gehen Sie zum Abfragen und Abrufen aller Bücher, deren Autor „Mark Twain“ ist, wie folgt vor:
```
public async Task QueryAsync(AWSCredentials credentials, RegionEndpoint region) {
var client = new AmazonDynamoDBClient(credentials, region);
Table books = Table.LoadTable(client, "Books");
var search = books.Query(new QueryOperationConfig() {
IndexName = "Author-Title-index",
Filter = new QueryFilter("Author", QueryOperator.Equal, "Mark Twain")
});
Console.WriteLine("ScanAsync: printing query response");
var documents = await search.GetRemainingAsync();
documents.ForEach((d) = > {
PrintDocument(d);
});
}
```
Der Scan-Beispiel-Code unten gibt alle Bücher in der Tabelle zurück:
```
public async Task ScanAsync(AWSCredentials credentials, RegionEndpoint region) {
var client = new AmazonDynamoDBClient(credentials, region);
Table books = Table.LoadTable(client, "Books");
var search = books.Scan(new ScanOperationConfig() {
ConsistentRead = true
});
Console.WriteLine("ScanAsync: printing scan response");
var documents = await search.GetRemainingAsync();
documents.ForEach((d) = > {
PrintDocument(d);
});
}
```
# Verwenden des Object Persistence-Modells
Das AWS Mobile SDK for .NET and Xamarin bietet ein Object Persistence-Modell, mit dem Sie Ihre clientseitigen Klassen einer DynamoDB -Tabelle zuordnen können. Jede Objekt-Instance wird dann einem Element in der entsprechenden Tabelle zugeordnet. Um Ihre clientseitigen Objekte in einer Tabelle zu speichern, stellt das Object Persistence-Modell die DynamoDBContext Klasse bereit, einen Eintrittspunkt für DynamoDB. Diese Klasse bietet Ihnen eine Verbindung zu DynamoDB und ermöglicht Ihnen den Zugriff auf Tabellen, die Ausführung verschiedener CRUD-Operationen und die Ausführung von Abfragen.
Das Object Persistence-Modell stellt keine API zum Erstellen, Aktualisieren und Löschen von Tabellen bereit. Es stellt ausschließlich Datenoperationen bereit. Zum Erstellen, Aktualisieren und Löschen von Tabellen müssen Sie die Low-Level-API verwenden. Anweisungen zur Verwendung der Low-Level-API finden Sie unter [Verwenden des DynamoDB Service APIsLevels ](dynamodb-integration-lowlevelapi.md).
## Overview
Das Object Persistence-Modell stellt eine Reihe von Attributen bereit, mit deren Hilfe Client-seitige Klassen Tabellen und Eigenschaften/Felder Tabellenattributen zugeordnet werden können. Das Object Persistence-Modell unterstützt die explizite und die Standardzuordnung zwischen Klasseneigenschaften und Tabellenattributen.
+ **Explizite **Zuweisung: Um eine Eigenschaft einem Primärschlüssel zuzuweisen, müssen Sie die Attribute DynamoDBHashKey und DynamoDBRangeKey Object Persistence-Modell verwenden. Außerdem gilt für Nicht-Primärschlüsselattribute, dass Sie die Zuweisung definieren müssen, indem Sie explizit das Attribut DynamoDBProperty hinzufügen, wenn der Name der Eigenschaft in Ihrer Klasse und das entsprechende Tabellenattribut, dem Sie ihn zuordnen möchten, nicht identisch sind.
+ **Standardzuordnung**: Standardmäßig ordnet das Object Persistence-Modell die Klasseneigenschaften Attributen mit identischem Namen in der Tabelle zu.
Sie müssen nicht jede Klasseneigenschaft zuordnen. Sie erkennen diese Eigenschaften, indem Sie das DynamoDBIgnore-Attribut hinzufügen. Beim Speichern und Abrufen einer Instance eines Objekts werden mit diesem Attribut markierte Eigenschaften ausgelassen.
## Unterstützte Datentypen
Das Object Persistence-Modell unterstützt eine Reihe primitiver .NET-Datentypen, Sammlungen sowie beliebige Datentypen. Das Modell unterstützt die folgenden primitiven Datentypen.
+ bool
+ Byte
+ char
+ DateTime
+ decimal, double, float
+ Int16, Int32, Int64
+ SByte
+ string
+ UInt16, UInt32, UInt64
Das Object Persistence-Modell unterstützt außerdem die .NET-Sammlungstypen. Dabei gelten folgende Einschränkungen:
+ Der Sammlungstyp muss eine ICollection Schnittstelle implementieren.
+ Der Sammlungstyp muss aus unterstützten primitiven Datentypen gebildet werden. Beispiel: ICollection , ICollection .
+ Der Sammlungstyp muss einen parameterlosen Konstruktor bereitstellen.
Weitere Informationen zum Object Persistence-Modell erhalten Sie unter [.NET Object Persistence-Modell](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DotNetSDKHighLevel.html).
## Erstellen eines DynamoDB Clients
So erstellen Sie einen DynamoDB Client:
```
var client = new AmazonDynamoDBClient(credentials,region);
DynamoDBContext context = new DynamoDBContext(client);
```
## CRUD-Operationen
### Speichern eines Objekts
Erstellen eines Objekts:
```
[DynamoDBTable("Books")]
public class Book {
[DynamoDBHashKey] // Hash key.
public string Id {
get;
set;
}
[DynamoDBGlobalSecondaryIndexHashKey]
public string Author {
get;
set;
}
[DynamoDBGlobalSecondaryIndexRangeKey]
public string Title {
get;
set;
}
public string ISBN {
get;
set;
}
public int Price {
get;
set;
}
public string PageCount {
get;
set;
}
}
Book myBook = new Book
{
Id = id,
Author = "Charles Dickens",
Title = "Oliver Twist",
ISBN = "111-1111111001",
Price = 10,
PageCount = 300
};
```
Speichern eines Objekts in einer DynamoDB Tabelle:
```
context.Save(myBook);
```
### Abrufen eines Objekts
Rufen Sie ein Objekt wie folgt ab:
```
Book retrievedBook = context.Load(1);
```
### Aktualisieren eines Objekts
Aktualisieren Sie ein Objekt wie folgt:
```
Book retrievedBook = context.Load(1);
retrievedBook.ISBN = "111-1111111001";
context.Save(retrievedBook);
```
### Objekte löschen
So löschen Sie ein Objekt:
```
Book retrievedBook = context.Load(1);
context.Delete(retrievedBook);
```
## Query und Scan
Gehen Sie zum Abfragen und Abrufen aller Bücher, deren Autor „Charles Dickens“ ist, wie folgt vor:
```
public async Task QueryAsync(AWSCredentials credentials, RegionEndpoint region) {
var client = new AmazonDynamoDBClient(credentials, region);
DynamoDBContext context = new DynamoDBContext(client);
var search = context.FromQueryAsync < Book > (new Amazon.DynamoDBv2.DocumentModel.QueryOperationConfig() {
IndexName = "Author-Title-index",
Filter = new Amazon.DynamoDBv2.DocumentModel.QueryFilter("Author", Amazon.DynamoDBv2.DocumentModel.QueryOperator.Equal, "Charles Dickens")
});
Console.WriteLine("items retrieved");
var searchResponse = await search.GetRemainingAsync();
searchResponse.ForEach((s) = > {
Console.WriteLine(s.ToString());
});
}
```
Der Scan-Beispiel-Code unten gibt alle Bücher in der Tabelle zurück:
```
public async Task ScanAsync(AWSCredentials credentials, RegionEndpoint region) {
var client = new AmazonDynamoDBClient(credentials, region);
DynamoDBContext context = new DynamoDBContext(client);
var search = context.FromScanAsync < Book > (new Amazon.DynamoDBv2.DocumentModel.ScanOperationConfig() {
ConsistentRead = true
});
Console.WriteLine("items retrieved");
var searchResponse = await search.GetRemainingAsync();
searchResponse.ForEach((s) = > {
Console.WriteLine(s.ToString());
});
}
```
# Verwenden des DynamoDB Service-Levels APIs
Mit dem Dynamo Service Level APIs können Sie Tabellen erstellen, aktualisieren und löschen. Sie können zudem typische CRUD-Operationen (Erstellen, Lesen, Aktualisieren, Löschen) für Elemente in einer Tabelle ausführen, die diese API verwendet.
## Erstellen eines DynamoDB Clients
So erstellen Sie einen DynamoDB Client:
```
AmazonDynamoDBClient client = new AmazonDynamoDBClient(credentials,region);
```
## CRUD-Operationen
### Speichern eines Elements
So speichern Sie ein Element in einer DynamoDB Tabelle:
```
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient(credentials,region);
// Define item attributes
Dictionary attributes = new Dictionary();
// Author is hash-key
attributes["Author"] = new AttributeValue { S = "Mark Twain" };
attributes["Title"] = new AttributeValue { S = "The Adventures of Tom Sawyer" };
attributes["PageCount"] = new AttributeValue { N = "275" };
attributes["Price"] = new AttributeValue{N = "10.00"};
attributes["Id"] = new AttributeValue{N="10"};
attributes["ISBN"] = new AttributeValue{S="111-1111111"};
// Create PutItem request
PutItemRequest request = new PutItemRequest
{
TableName = "Books",
Item = attributes
};
// Issue PutItem request
var response = await client.PutItemAsync(request);
```
### Abrufen eines Elements
Rufen Sie ein Element wie folgt ab:
```
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient(credentials,region);
Dictionary key = new Dictionary
{
{ "Id", new AttributeValue { N = "10" } }
};
// Create GetItem request
GetItemRequest request = new GetItemRequest
{
TableName = "Books",
Key = key,
};
// Issue request
var result = await client.GetItemAsync(request);
// View response
Console.WriteLine("Item:");
Dictionary item = result.Item;
foreach (var keyValuePair in item)
{
Console.WriteLine("Author := {0}", item["Author"]);
Console.WriteLine("Title := {0}", item["Title"]);
Console.WriteLine("Price:= {0}", item["Price"]);
Console.WriteLine("PageCount := {0}", item["PageCount"]);
}
```
### Aktualisieren eines Elements
Aktualisieren Sie ein Element wie folgt:
```
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient(credentials,region);
Dictionary key = new Dictionary
{
{ "Id", new AttributeValue { N = "10" } }
};
// Define attribute updates
Dictionary updates = new Dictionary();
// Add a new string to the item's Genres SS attribute
updates["Genres"] = new AttributeValueUpdate()
{
Action = AttributeAction.ADD,
Value = new AttributeValue { SS = new List { "Bildungsroman" } }
};
// Create UpdateItem request
UpdateItemRequest request = new UpdateItemRequest
{
TableName = "Books",
Key = key,
AttributeUpdates = updates
};
// Issue request
var response = await client.UpdateItemAsync(request);
```
### Löschen eines Elements
So löschen Sie einen Artikel:
```
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient(credentials,region);
Dictionary key = new Dictionary
{
{ "Id", new AttributeValue { N = "10" } }
};
// Create DeleteItem request
DeleteItemRequest request = new DeleteItemRequest
{
TableName = "Books",
Key = key
};
// Issue request
var response = await client.DeleteItemAsync(request);
```
## Query und Scan
Gehen Sie zum Abfragen und Abrufen aller Bücher, deren Autor „Mark Twain“ ist, wie folgt vor:
```
public void Query(AWSCredentials credentials, RegionEndpoint region) {
using(var client = new AmazonDynamoDBClient(credentials, region)) {
var queryResponse = await client.QueryAsync(new QueryRequest() {
TableName = "Books",
IndexName = "Author-Title-index",
KeyConditionExpression = "Author = :v_Id",
ExpressionAttributeValues = new Dictionary < string, AttributeValue > {
{
":v_Id", new AttributeValue {
S = "Mark Twain"
}
}
}
});
queryResponse.Items.ForEach((i) = > {
Console.WriteLine(i["Title"].S);
});
}
}
```
Der Scan-Beispiel-Code unten gibt alle Bücher in der Tabelle zurück:
```
public void Scan(AWSCredentials credentials, RegionEndpoint region) {
using(var client = new AmazonDynamoDBClient(credentials, region)) {
var queryResponse = client.Scan(new ScanRequest() {
TableName = "Books"
});
queryResponse.Items.ForEach((i) = > {
Console.WriteLine(i["Title"].S);
});
}
}
```