Der AWS SDK für .NET V3 ist in den Wartungsmodus übergegangen. Wir empfehlen Ihnen, auf [AWS SDK für .NET V4](https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/welcome.html) zu migrieren. Weitere Einzelheiten und Informationen zur Migration finden Sie in unserer [Ankündigung zum Wartungsmodus](https://aws.amazon.com/blogs/developer/aws-sdk-for-net-v3-maintenance-mode-announcement/). 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. # Verwenden von Amazon DynamoDB NoSQL-Datenbanken **Anmerkung** Die Programmiermodelle in diesen Themen sind sowohl in.NET Framework als auch in .NET (Core) vorhanden, aber die Aufrufkonventionen unterscheiden sich, unabhängig davon, ob sie synchron oder asynchron sind. Der AWS SDK für .NET unterstützt Amazon DynamoDB, einen schnellen NoSQL-Datenbankservice, der von angeboten wird. AWS Das SDK bietet drei Programmiermodelle für die Kommunikation mit DynamoDB: das *Low-Level-Modell*, das *Dokumentenmodell* und das *Objektpersistenzmodell*. Die folgenden Informationen stellen diese und ihre Modelle vor APIs, enthalten Beispiele dafür, wie und wann sie zu verwenden sind, und enthalten Links zu zusätzlichen DynamoDB-Programmierressourcen in der. AWS SDK für .NET ## Low-Level-Modell Das Low-Level-Programmiermodell umschließt direkte Aufrufe an den DynamoDB-Dienst. [Sie greifen über den Amazon.Dynamo-Namespace auf dieses Modell zu. DBv2](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/DynamoDBv2/NDynamoDBv2.html) Von den drei Modellen müssen Sie für das Low-Level-Modell den meisten Code schreiben. Beispielsweise müssen Sie.NET-Datentypen in ihre Entsprechungen in DynamoDB konvertieren. Allerdings bietet Ihnen dieses Modell Zugriff auf die meisten Funktionen. Die folgenden Beispiele zeigen, wie Sie das Low-Level-Modell verwenden, um eine Tabelle zu erstellen, eine Tabelle zu ändern und Elemente in eine Tabelle in DynamoDB einzufügen. ### Erstellen einer Tabelle Im folgenden Beispiel erstellen Sie eine Tabelle mithilfe der `CreateTable`-Methode der Klasse `AmazonDynamoDBClient`. Die `CreateTable`-Methode verwendet eine Instance der `CreateTableRequest`-Klasse, die Merkmale wie erforderliche Elementattributnamen, Primärschlüsseldefinition und Durchsatzkapazität enthält. Die `CreateTable`-Methode gibt eine Instance der `CreateTableResponse`-Klasse zurück. ``` // using Amazon.DynamoDBv2; // using Amazon.DynamoDBv2.Model; var client = new AmazonDynamoDBClient(); Console.WriteLine("Getting list of tables"); List currentTables = client.ListTables().TableNames; Console.WriteLine("Number of tables: " + currentTables.Count); if (!currentTables.Contains("AnimalsInventory")) { var request = new CreateTableRequest { TableName = "AnimalsInventory", AttributeDefinitions = new List { new AttributeDefinition { AttributeName = "Id", // "S" = string, "N" = number, and so on. AttributeType = "N" }, new AttributeDefinition { AttributeName = "Type", AttributeType = "S" } }, KeySchema = new List { 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); } ``` ### Überprüfen, ob eine Tabelle für Änderungen bereit ist Bevor Sie eine Tabelle ändern oder modifizieren können, muss die Tabelle für die Änderung bereit stehen. Das folgende Beispiel zeigt, wie das Low-Level-Modell verwendet wird, um zu überprüfen, ob eine Tabelle in DynamoDB bereit ist. In diesem Beispiel wird die zu überprüfende Zieltabelle durch die `DescribeTable`-Methode der `AmazonDynamoDBClient`-Klasse referenziert. Alle fünf Sekunden überprüft der Code den Wert der `TableStatus`-Eigenschaft der Tabelle. Sobald der Status auf `ACTIVE` gesetzt wird, steht die Tabelle zum Ändern bereit. ``` // 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); ``` ### Einfügen eines Elements in eine Tabelle Im folgenden Beispiel verwenden Sie das Low-Level-Modell, um zwei Elemente in eine Tabelle in DynamoDB einzufügen. Jedes Element wird durch die `PutItem`-Methode der `AmazonDynamoDBClient`-Klasse mithilfe einer Instance der `PutItemRequest`-Klasse eingefügt. Jede der beiden Instances der `PutItemRequest`-Klasse akzeptiert den Namen der Tabelle, in die die Elemente eingefügt werden, sowie eine Reihe von Elementattributwerten. ``` // using Amazon.DynamoDBv2; // using Amazon.DynamoDBv2.Model; var client = new AmazonDynamoDBClient(); var request1 = new PutItemRequest { TableName = "AnimalsInventory", Item = new Dictionary { { "Id", new AttributeValue { N = "1" }}, { "Type", new AttributeValue { S = "Dog" }}, { "Name", new AttributeValue { S = "Fido" }} } }; var request2 = new PutItemRequest { TableName = "AnimalsInventory", Item = new Dictionary { { "Id", new AttributeValue { N = "2" }}, { "Type", new AttributeValue { S = "Cat" }}, { "Name", new AttributeValue { S = "Patches" }} } }; client.PutItem(request1); client.PutItem(request2); ``` ## Dokument-Modell Das Modell der Dokumentenprogrammierung bietet eine einfachere Möglichkeit, mit Daten in DynamoDB zu arbeiten. Dieses Modell ist speziell für den Zugriff auf Tabellen und Elemente in Tabellen vorgesehen. [Sie greifen über Amazon.Dynamo auf dieses Modell zu. DBv2 DocumentModel](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/DynamoDBv2/NDynamoDBv2DocumentModel.html)Namespace. Im Vergleich zum Low-Level-Programmiermodell ist das Dokumentmodell einfacher anhand von DynamoDB-Daten zu codieren. Sie müssen beispielsweise nicht so viele .NET-Datentypen in ihre Entsprechungen in DynamoDB konvertieren. Allerdings bietet dieses Modell auf weniger Funktionen Zugriff als das Low-Level-Programmierungsmodell. Mit diesem Modell können Sie beispielsweise Elemente in Tabellen erstellen, abrufen, aktualisieren und löschen. Zum Erstellen der Tabellen müssen Sie jedoch das Low-Level-Modell verwenden. Im Vergleich zum Object Persistence-Modell müssen Sie bei diesem Modell zum Speichern, Laden und Abfragen von .NET-Objekten mehr Code schreiben. Weitere Informationen zum DynamoDB-Dokumentprogrammiermodell finden Sie [unter.NET: Document Model](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DotNetSDKMidLevel.html) im [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/) Developer Guide. Die folgenden Abschnitte enthalten Informationen zum Erstellen einer Darstellung der gewünschten DynamoDB-Tabelle sowie Beispiele zur Verwendung des Dokumentmodells zum Einfügen von Elementen in Tabellen und zum Abrufen von Elementen aus Tabellen. ### Erstellen Sie eine Darstellung der Tabelle Um Datenoperationen mithilfe des Dokumentmodells durchzuführen, müssen Sie zunächst eine Instanz der `Table` Klasse erstellen, die eine bestimmte Tabelle darstellt. Dafür gibt es hauptsächlich zwei Möglichkeiten. **LoadTable Methode** Der erste Mechanismus besteht darin, eine der statischen `LoadTable` Methoden der [https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/DynamoDBv2/TTable.html](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/DynamoDBv2/TTable.html)Klasse zu verwenden, ähnlich dem folgenden Beispiel: ``` var client = new AmazonDynamoDBClient(); Table table = Table.LoadTable(client, "Reply"); ``` **Anmerkung** Dieser Mechanismus funktioniert zwar, kann aber unter bestimmten Bedingungen aufgrund von Kaltstart- und Threadpool-Verhalten manchmal zu zusätzlicher Latenz oder Deadlocks führen. Weitere Informationen zu diesen Verhaltensweisen finden Sie im Blogbeitrag [Verbesserte DynamoDB-Initialisierungsmuster](https://aws.amazon.com/blogs/developer/improved-dynamodb-initialization-patterns-for-the-aws-sdk-for-net/) für den. AWS SDK für .NET **TableBuilder** Ein alternativer Mechanismus, die [https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/DynamoDBv2/TTableBuilder.html](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/DynamoDBv2/TTableBuilder.html)Klasse, wurde in [Version 3.7.203](https://www.nuget.org/packages/AWSSDK.DynamoDBv2/3.7.203) des .Dynamo-Pakets eingeführt. AWSSDK DBv2 NuGet Mit diesem Mechanismus können die oben genannten Verhaltensweisen behoben werden, indem bestimmte implizite Methodenaufrufe, insbesondere die Methode, entfernt werden. `DescribeTable` Dieser Mechanismus wird ähnlich wie im folgenden Beispiel verwendet: ``` 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(); ``` Weitere Informationen zu diesem alternativen Mechanismus finden Sie erneut im Blogbeitrag [Verbesserte DynamoDB-Initialisierungsmuster](https://aws.amazon.com/blogs/developer/improved-dynamodb-initialization-patterns-for-the-aws-sdk-for-net/) für die. AWS SDK für .NET ### Ein Element in eine Tabelle einfügen Im folgenden Beispiel wird eine Antwort mithilfe der `PutItemAsync` Methode der `Table` Klasse in die Antworttabelle eingefügt. Die `PutItemAsync`-Methode übernimmt eine Instance der `Document`-Klasse, wobei die `Document`-Klasse einfach eine Sammlung von initialisierten Attributen ist. ``` 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); ``` ### Ein Element aus einer Tabelle abrufen Im folgenden Beispiel wird eine Antwort über die `GetItemAsync` Methode der `Table` Klasse abgerufen. Um zu ermitteln, welche Antwort abgerufen werden soll, verwendet die `GetItemAsync` Methode den hash-and-range Primärschlüssel der Zielantwort. ``` 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"]); ``` Im vorherigen Beispiel werden die Tabellenwerte implizit in Zeichenketten für die `WriteLine` Methode konvertiert. Sie können explizite Konvertierungen durchführen, indem Sie die verschiedenen „As [type]“ -Methoden der `DynamoDBEntry` Klasse verwenden. Beispielsweise können Sie den Wert für mit der folgenden `AsGuid()` Methode explizit `Id` von einem `Primitive` Datentyp in eine GUID konvertieren: ``` var guid = reply["Id"].AsGuid(); ``` ## Object Persistence-Modell Das Objektpersistenz-Programmiermodell wurde speziell für das Speichern, Laden und Abfragen von .NET-Objekten in DynamoDB entwickelt. [Sie greifen über Amazon.Dynamo auf dieses Modell zu. DBv2 DataModel](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/DynamoDBv2/NDynamoDBv2DataModel.html)Namespace. Von den drei Modellen ist das Objektpersistenzmodell am einfachsten zu verwenden, wenn Sie DynamoDB-Daten speichern, laden oder abfragen. Sie arbeiten beispielsweise direkt mit DynamoDB-Datentypen. Dieses Modell bietet jedoch nur Zugriff auf Operationen, die .NET-Objekte in DynamoDB speichern, laden und abfragen. Mit diesem Modell können Sie beispielsweise Elemente in Tabellen erstellen, abrufen, aktualisieren und löschen. Sie müssen jedoch zunächst die Tabellen mithilfe des Low-Level-Modells erstellen und dann dieses Modell verwenden, um die .NET-Klassen den Tabellen zuzuordnen. Weitere Informationen zum DynamoDB-Programmiermodell für Objektpersistenz finden Sie [unter.NET: Object persistence model](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DotNetSDKHighLevel.html) im [Amazon](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/) DynamoDB Developer Guide. Die folgenden Beispiele zeigen, wie Sie eine .NET-Klasse definieren, die ein DynamoDB-Element darstellt, eine Instanz der .NET-Klasse verwenden, um ein Element in eine DynamoDB-Tabelle einzufügen, und wie Sie eine Instanz der .NET-Klasse verwenden, um ein Element aus der Tabelle abzurufen. ### Definieren einer .NET-Klasse, die ein Element in einer Tabelle darstellt Im folgenden Beispiel für eine Klassendefinition gibt das `DynamoDBTable` Attribut den Tabellennamen an, während die `DynamoDBRangeKey` Attribute `DynamoDBHashKey` und den hash-and-range Primärschlüssel der Tabelle modellieren. Das `DynamoDBGlobalSecondaryIndexHashKey` Attribut ist so definiert, dass eine Abfrage nach Antworten eines bestimmten Autors erstellt werden kann. ``` 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; } } ``` ### Erstellen eines Kontextes für das Objektpersistenzmodell Um das Objektpersistenz-Programmiermodell für DynamoDB zu verwenden, müssen Sie einen Kontext erstellen, der eine Verbindung zu DynamoDB bereitstellt und es Ihnen ermöglicht, auf Tabellen zuzugreifen, verschiedene Operationen durchzuführen und Abfragen auszuführen. **Grundlegender Kontext** Das folgende Beispiel zeigt, wie der einfachste Kontext erstellt wird. ``` using Amazon.DynamoDBv2; using Amazon.DynamoDBv2.DataModel; var client = new AmazonDynamoDBClient(); var context = new DynamoDBContext(client); ``` **Kontext mit DisableFetchingTableMetadata Eigentum** Das folgende Beispiel zeigt, wie Sie zusätzlich die `DisableFetchingTableMetadata` Eigenschaft der `DynamoDBContextConfig` Klasse festlegen können, um implizite Aufrufe der `DescribeTable` Methode zu verhindern. ``` using Amazon.DynamoDBv2; using Amazon.DynamoDBv2.DataModel; var client = new AmazonDynamoDBClient(); var context = new DynamoDBContext(client, new DynamoDBContextConfig { DisableFetchingTableMetadata = true }); ``` Wenn die `DisableFetchingTableMetadata` Eigenschaft auf `false` (Standard) gesetzt ist, wie im ersten Beispiel gezeigt, können Sie Attribute, die die Schlüssel- und Indexstruktur von Tabellenelementen beschreiben, aus der `Reply` Klasse weglassen. Diese Attribute werden stattdessen durch einen impliziten Aufruf der Methode abgeleitet. `DescribeTable` Sie `DisableFetchingTableMetadata` ist`true`, wie im zweiten Beispiel gezeigt, auf Methoden des Objektpersistenzmodells gesetzt, die ausschließlich auf den in der Klasse definierten Attributen `QueryAsync` basieren. `SaveAsync` `Reply` In diesem Fall erfolgt kein Aufruf der `DescribeTable` Methode. **Anmerkung** Unter bestimmten Bedingungen können Aufrufe der `DescribeTable` Methode aufgrund von Kaltstart- und Threadpool-Verhalten manchmal zu zusätzlicher Latenz oder Deadlocks führen. Aus diesem Grund ist es manchmal vorteilhaft, Aufrufe dieser Methode zu vermeiden. Weitere Informationen zu diesen Verhaltensweisen finden Sie im Blogbeitrag [Verbesserte DynamoDB-Initialisierungsmuster](https://aws.amazon.com/blogs/developer/improved-dynamodb-initialization-patterns-for-the-aws-sdk-for-net/) für den. AWS SDK für .NET ### Verwenden einer Instanz der .NET-Klasse zum Einfügen eines Elements in eine Tabelle In diesem Beispiel wird ein Element über die `SaveAsync` Methode der `DynamoDBContext` Klasse eingefügt, die eine initialisierte Instanz der .NET-Klasse verwendet, die das Element darstellt. ``` 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, new DynamoDBOperationConfig { IndexName = "PostedBy-Message-index" }); ``` ### Verwenden einer Instanz einer .NET-Klasse, um Elemente aus einer Tabelle abzurufen In diesem Beispiel wird eine Abfrage erstellt, um alle Datensätze von „Author1" mithilfe der `QueryAsync` Methode der `DynamoDBContext` Klasse zu finden. Anschließend werden die Elemente mit der `GetNextSetAsync` Methode der Abfrage abgerufen. ``` 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("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); } ``` ### Zusätzliche Informationen zum Objektpersistenzmodell Die oben gezeigten Beispiele und Erläuterungen beinhalten manchmal eine Eigenschaft der `DisableFetchingTableMetadata` aufgerufenen `DynamoDBContext` Klasse. Diese Eigenschaft, die in [Version 3.7.203 des AWSSDK DBv2 NuGet .Dynamo-Pakets eingeführt wurde, ermöglicht es Ihnen, bestimmte Bedingungen zu vermeiden, die](https://www.nuget.org/packages/AWSSDK.DynamoDBv2/3.7.203) aufgrund von Kaltstart- und Threadpool-Verhalten zu zusätzlichen Latenzen oder Deadlocks führen könnten. Weitere Informationen finden Sie im Blogbeitrag [Verbesserte DynamoDB-Initialisierungsmuster](https://aws.amazon.com/blogs/developer/improved-dynamodb-initialization-patterns-for-the-aws-sdk-for-net/) für. AWS SDK für .NET Im Folgenden finden Sie einige zusätzliche Informationen zu dieser Eigenschaft. + Diese Eigenschaft kann global in Ihrer `app.config` `web.config` OR-Datei festgelegt werden, wenn Sie.NET Framework verwenden. + Diese Eigenschaft kann mithilfe der [https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Amazon/TAWSConfigsDynamoDB.html](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Amazon/TAWSConfigsDynamoDB.html)Klasse global festgelegt werden, wie im folgenden Beispiel gezeigt. ``` // Set the DisableFetchingTableMetadata property globally // before constructing any context objects. AWSConfigsDynamoDB.Context.DisableFetchingTableMetadata = true; var client = new AmazonDynamoDBClient(); var context = new DynamoDBContext(client); ``` + In einigen Fällen können Sie einer .NET-Klasse keine DynamoDB-Attribute hinzufügen, z. B. wenn die Klasse in einer Abhängigkeit definiert ist. In solchen Fällen ist es dennoch möglich, die Eigenschaft zu nutzen. `DisableFetchingTableMetadata` Verwenden Sie dazu zusätzlich zur `DisableFetchingTableMetadata` Eigenschaft die [https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/DynamoDBv2/TTableBuilder.html](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/DynamoDBv2/TTableBuilder.html)Klasse. Die `TableBuilder` Klasse wurde auch in [Version 3.7.203 des AWSSDK DBv2 NuGet .Dynamo-Pakets](https://www.nuget.org/packages/AWSSDK.DynamoDBv2/3.7.203) eingeführt. ``` // Set the DisableFetchingTableMetadata property globally // before constructing any context objects. AWSConfigsDynamoDB.Context.DisableFetchingTableMetadata = true; var client = new AmazonDynamoDBClient(); var context = new DynamoDBContext(client); 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(); // This registers the "Reply" table we constructed via the builder. context.RegisterTableDefinition(table); // Now operations like this will work, // even if the Reply class was not annotated with this index. var query = context.QueryAsync("Author1", new DynamoDBOperationConfig() { IndexName = "PostedBy-Message-index" }); ``` ## Weitere Informationen **Verwendung von DynamoDB AWS SDK für .NET zum Programmieren, Informationen und Beispiele** + [DynamoDB APIs](http://blogs.aws.amazon.com/net/post/Tx17SQHVEMW8MXC/DynamoDB-APIs) + [DynamoDB Series Kickoff](http://blogs.aws.amazon.com/net/post/Tx2XQOCY08QMTKO/DynamoDB-Series-Kickoff) + [DynamoDB Series - Document Model](http://blogs.aws.amazon.com/net/post/Tx2R0WG46GQI1JI/DynamoDB-Series-Document-Model) + [DynamoDB Series - Conversion Schemas](http://blogs.aws.amazon.com/net/post/Tx2TCOGWG7ARUH5/DynamoDB-Series-Conversion-Schemas) + [DynamoDB Series - Object Persistence Model](http://blogs.aws.amazon.com/net/post/Tx20L86FLMBW51P/DynamoDB-Series-Object-Persistence-Model) + [DynamoDB Series - Expressions](http://blogs.aws.amazon.com/net/post/TxZQM7VA9AUZ9L/DynamoDB-Series-Expressions) + [Verwenden von Ausdrücken mit Amazon DynamoDB und AWS SDK für .NET](dynamodb-expressions.md) + [JSON-Unterstützung in Amazon DynamoDB](dynamodb-json.md) **Low-Level-Modell, Informationen und Beispiele** + [Arbeiten mit Tabellen mithilfe der AWS SDK für .NET Low-Level-API](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LowLevelDotNetWorkingWithTables.html) + [Mit Elementen arbeiten, die die AWS SDK für .NET Low-Level-API verwenden](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LowLevelDotNetItemCRUD.html) + [Abfragen von Tabellen mithilfe der Low-Level-API AWS SDK für .NET](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LowLevelDotNetQuerying.html) + [Scannen von Tabellen mithilfe der AWS SDK für .NET Low-Level-API](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LowLevelDotNetScanning.html) + [Arbeiten mit lokalen Sekundärindizes mithilfe der AWS SDK für .NET Low-Level-API](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LSILowLevelDotNet.html) + [Arbeiten mit globalen Sekundärindizes mithilfe der Low-Level-API AWS SDK für .NET](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GSILowLevelDotNet.html) **Dokumentenmodell, Informationen und Beispiele** + [DynamoDB-Datentypen](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataModel.html#DataModel.DataTypes) + [Dynamo DBEntry](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/TDynamoDBv2DocumentModelDynamoDBEntry.html) + [.NET: Dokumentmodell](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DotNetSDKMidLevel.html) **Modell, Informationen und Beispiele für Objektpersistenz** + [.NET: "Object Persistence"-Modell](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DotNetSDKHighLevel.html) **Weitere nützliche Informationen** + Informationen [Integration AWS mit.NET Aspire](aspire-integrations.md) zur lokalen Entwicklung mit Amazon DynamoDB über.NET Aspire finden Sie unter. **Topics** + [Low-Level-Modell](#dynamodb-intro-apis-low-level) + [Dokument-Modell](#dynamodb-intro-apis-document) + [Object Persistence-Modell](#dynamodb-intro-apis-object-persistence) + [Weitere Informationen](#dynamodb-intro-more-info) + [Verwenden von Ausdrücken](dynamodb-expressions.md) + [JSON-Support](dynamodb-json.md)