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. # Arbeiten mit dem Object Persistence-Modell von .NET und DynamoDB Das AWS SDK für .NET bietet ein Objektpersistenzmodell, mit dem Sie Ihre clientseitigen Klassen Amazon DynamoDB-Tabellen zuordnen können. Die einzelnen Objekt-Instances werden anschließend einem Element in den entsprechenden Tabellen zugeordnet. Zum Speichern der clientseitigen Objekte in den Tabellen stellt das Object-Persistence-Modell die Klasse `DynamoDBContext` bereit, einen Eintrittspunkt für DynamoDB. Mit dieser Klasse verfügen Sie über eine Verbindung zu DynamoDB, können auf Tabellen zugreifen und verschiedene CRUD-Operationen sowie Abfragen ausführen. Das Objektpersistenzmodell bietet eine Reihe von Attributen, um clientseitige Klassen Tabellen und Tabellenattributen zuzuordnen. properties/fields **Anmerkung** Das Object Persistence-Modell stellt keine API zum Erstellen, Aktualisieren oder Löschen von Tabellen bereit. Es stellt ausschließlich Datenoperationen bereit. Sie können nur die AWS SDK für .NET Low-Level-API verwenden, um Tabellen zu erstellen, zu aktualisieren und zu löschen. Das folgende Beispiel zeigt, wie das Object Persistence-Modell funktioniert. Es wird mit der Tabelle `ProductCatalog` gestartet. Es besitzt `Id` als Primärschlüssel. ``` ProductCatalog(Id, ...) ``` Angenommen, Sie besitzen die Klasse `Book` mit den Eigenschaften `Title`, `ISBN` und `Authors`. Sie können die Klasse `Book` der Tabelle `ProductCatalog` zuordnen, indem Sie die durch das Object Persistence-Modell definierten Attribute hinzufügen wie im folgenden C\$1-Codeausschnitt gezeigt. **Example** ``` [DynamoDBTable("ProductCatalog")] public class Book { [DynamoDBHashKey] public int Id { get; set; } public string Title { get; set; } public int ISBN { get; set; } [DynamoDBProperty("Authors")] public List 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 Das Object Persistence-Modell unterstützt eine Reihe primitiver .NET-Datentypen, Sammlungen sowie beliebiger 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 Objektpersistenzmodell unterstützt auch die .NET-Sammlungstypen. `DynamoDBContext`ist in der Lage, konkrete Sammlungstypen und einfache Plain Old CLR-Objekte () POCOs zu konvertieren. In der folgenden Tabelle ist das Mapping der vorhergehenden .NET-Typen zu den DynamoDB-Typen zusammengefasst. **** | .NET-primitiver Typ | DynamoDB-Typ | | --- | --- | | Alle Zahlentypen | `N` (Zahlentyp) | | Alle Zeichenfolgetypen | `S` (Zeichenfolgetyp) | | MemoryStream, Byte [] | `B` (Binärtyp) | | bool | N (Zahlentyp) 0 repräsentiert False und 1 steht für True. | | Sammlungstypen | BS-(Binärsatz)-Typ, SS-(Zeichenfolgesatz)-Typ und NS-(Zahlensatz)-Typ. | | DateTime | S (Zeichenfolgetyp). Die DateTime-Werte werden als ISO-8601-formatierte Zeichenfolgen gespeichert. | Das Object Persistence-Modell unterstützt außerdem beliebige Datentypen. Allerdings müssen Sie einen Konverter-Code bereitstellen, um die komplexen Typen den DynamoDB-Typen zuzuordnen. **Anmerkung** Leere Binärwerte werden unterstützt. Das Lesen von leeren Zeichenfolgenwerten wird unterstützt. Leere Zeichenfolgen-Attributwerte werden beim Schreiben zu DynamoDB in Attributwerten vom Typ Zeichenfolgensatz unterstützt. Leere Zeichenfolgen-Attributwerte des Zeichenfolgentyps und leere Zeichenfolgenwerte innerhalb des Listen- oder Map-Typs werden aus Schreibanforderungen gelöscht. # DynamoDB-Attribute aus dem Object Persistence-Modell von .NET Dieser Abschnitt beschreibt die Attribute, die das Object-Persistence-Modell bereitstellt, damit Sie Ihre Klassen und Eigenschaften den DynamoDB-Tabellen und -Attributen zuordnen können. **Anmerkung** In den folgenden Attributen werden ausschließlich `DynamoDBTable` und `DynamoDBHashKey` benötigt. ## Dynamo DBGlobal SecondaryIndexHashKey Ordnet eine Klasseneigenschaft dem Partitionsschlüssel eines globalen sekundären Indexes zu. Verwenden Sie dieses Attribut, wenn Sie einen globalen sekundären Index `Query` möchten. ## Dynamo DBGlobal SecondaryIndexRangeKey Ordnet eine Klasseneigenschaft dem Sortierungsschlüssel eines globalen sekundären Indexes zu. Verwenden Sie dieses Attribut, wenn Sie eine `Query` für einen globalen sekundären Schlüssel ausführen müssen und die Ergebnisse mithilfe des Indexsortierschlüssels verfeinern möchten. ## Dynamo-Schlüssel DBHash Ordnet eine Klasseneigenschaft dem Partitionsschlüssel des Primärschlüssels der Tabelle zu. Die Primärschlüsselattribute können nicht ein Sammlungstyp sein. Im folgenden C\$1-Codebeispiel werden die Klasse `Book` der Tabelle `ProductCatalog` und die Eigenschaft `Id` dem Partitionsschlüssel des Primärschlüssels der Tabelle zugeordnet. ``` [DynamoDBTable("ProductCatalog")] public class Book { [DynamoDBHashKey] public int Id { get; set; } // Additional properties go here. } ``` ## Dynamo DBIgnore Zeigt an, dass die zugeordnete Eigenschaft ignoriert werden sollte. Wenn Sie keine Klasseneigenschaften speichern möchten, können Sie dieses Attribut hinzufügen, um `DynamoDBContext` anzuweisen, diese Eigenschaft beim Speichern von Objekten zur Tabelle nicht einzufügen. ## Dynamo DBLocal SecondaryIndexRangeKey Ordnet eine Klasseneigenschaft dem Sortierungsschlüssel eines lokalen sekundären Indexes zu. Verwenden Sie dieses Attribut, wenn Sie eine `Query` für einen lokalen sekundären Index ausführen müssen und die Ergebnisse mithilfe des Indexsortierschlüssels verfeinern möchten. ## Dynamo DBProperty Ordnet eine Klasseneigenschaft einem Tabellenattribut zu. Wenn die Klasseneigenschaft einem Tabellenattribut mit dem gleichen Namen zugeordnet ist, müssen Sie dieses Attribut nicht angeben. Wenn die Namen jedoch nicht identisch sind, können Sie diesen Tag verwenden, um das Mapping bereitzustellen. In der folgenden C\$1-Anweisung ordnet `DynamoDBProperty` die Eigenschaft `BookAuthors` dem Attribut `Authors` in der Tabelle zu. ``` [DynamoDBProperty("Authors")] public List BookAuthors { get; set; } ``` `DynamoDBContext` verwendet diese Mappinginformationen, um beim Speichern von Objektdaten zur entsprechenden Tabelle das Attribut `Authors` zu erstellen. ## Dynamo DBRenamable Gibt einen alternativen Namen für eine Klasseneigenschaft an. Dies eignet sich für das Schreiben eines benutzerdefinierten Konverters, um beliebige Daten einer DynamoDB-Tabelle, in der sich der Name der Klasseneigenschaft von dem des Tabellenattributs unterscheidet, zuzuordnen. ## Dynamo-Schlüssel DBRange Ordnet eine Klasseneigenschaft dem Sortierschlüssel des Primärschlüssels der Tabelle zu. Wenn die Tabelle über einen zusammengesetzten Primärschlüssel (Partitionsschlüssel und Sortierschlüssel) verfügt, müssen Sie sowohl das Attribut `DynamoDBHashKey` als auch das Attribut `DynamoDBRangeKey` im Klassenmapping angeben. Die Beispieltabelle `Reply` verfügt über einen Primärschlüssel, der aus dem Partitionsschlüssel `Id` und dem Sortierschlüssel `Replenishment` besteht. Im folgenden C\$1-Codebeispiel wird die Klasse `Reply` der Tabelle `Reply` zugeordnet. Die Klassendefinition gibt ebenfalls an, dass zwei ihrer Eigenschaften den Primärschlüsseln zugeordnet werden. ``` [DynamoDBTable("Reply")] public class Reply { [DynamoDBHashKey] public int ThreadId { get; set; } [DynamoDBRangeKey] public string Replenishment { get; set; } // Additional properties go here. } ``` ## Dynamo DBTable Identifiziert die Zieltabelle in DynamoDB, zu der die Klasse zugeordnet wird. Im folgenden C\$1-Codebeispiel wird beispielsweise die Klasse `Developer` der Tabelle `People` in DynamoDB zugeordnet. ``` [DynamoDBTable("People")] public class Developer { ...} ``` Dieses Attribut kann geerbt oder überschrieben werden. + Das `DynamoDBTable`-Attribut kann geerbt werden. Wenn Sie im vorherigen Beispiel die neue Klasse `Lead` hinzufügen, die von der Klasse `Developer` erbt, wird diese ebenfalls der Tabelle `People` zugeordnet. Sowohl das Objekt `Developer` als auch das Objekt `Lead` werden in der Tabelle `People` gespeichert. + Das `DynamoDBTable`-Attribut kann auch überschrieben werden. Im folgenden C\$1-Codebeispiel erbt die Klasse `Manager` von der Klasse `Developer`. Durch das explizite Hinzufügen des Attributs `DynamoDBTable` wird die Klasse jedoch einer anderen Tabelle (`Managers`) zugeordnet. ``` [DynamoDBTable("Managers")] public class Manager : Developer { ...} ``` Sie können den optionalen Parameter `LowerCamelCaseProperties` hinzufügen, um DynamoDB aufzufordern, den ersten Buchstaben des Eigenschaftsnamens beim Speichern von Objekten in einer Tabelle klein zu schreiben wie im folgenden C\$1-Codebeispiel gezeigt. ``` [DynamoDBTable("People", LowerCamelCaseProperties=true)] public class Developer { string DeveloperName; ... } ``` Beim Speichern von Instances der Klasse `Developer` speichert `DynamoDBContext` die Eigenschaft `DeveloperName` als `developerName`. ## Dynamo DBVersion Identifiziert eine Klasseneigenschaft für das Speichern der Versionsnummer des Elements. Weitere Informationen über das Versioning finden Sie unter [Optimistisches Sperren mit DynamoDB und dem AWS SDK für .NET Objektpersistenzmodell](DynamoDBContext.VersionSupport.md). # DBContext Dynamo-Klasse aus dem .NET-Objektpersistenzmodell Die `DynamoDBContext`-Klasse ist der Eintrittspunkt zu der Amazon-DynamoDB-Datenbank. Mit dieser Klasse verfügen Sie über eine Verbindung zu DynamoDB und können auf die Daten in unterschiedlichen Tabellen zugreifen, verschiedene CRUD-Operationen durchführen sowie Abfragen ausführen. Die Klasse `DynamoDBContext`-stellt folgende Methoden bereit. **Topics** + [Erstellen MultiTable BatchGet](#w2aac17b9c21c23c39b7) + [Erschaffen MultiTable BatchWrite](#w2aac17b9c21c23c39b9) + [CreateBatchGet](#w2aac17b9c21c23c39c11) + [CreateBatchWrite](#w2aac17b9c21c23c39c13) + [Delete](#w2aac17b9c21c23c39c15) + [Dispose](#w2aac17b9c21c23c39c17) + [ExecuteBatchGet](#w2aac17b9c21c23c39c19) + [ExecuteBatchWrite](#w2aac17b9c21c23c39c21) + [FromDocument](#w2aac17b9c21c23c39c23) + [FromQuery](#w2aac17b9c21c23c39c25) + [FromScan](#w2aac17b9c21c23c39c27) + [GetTargetTable](#w2aac17b9c21c23c39c29) + [Load](#w2aac17b9c21c23c39c31) + [Query](#w2aac17b9c21c23c39c33) + [Save](#w2aac17b9c21c23c39c35) + [Scan](#w2aac17b9c21c23c39c37) + [ToDocument](#w2aac17b9c21c23c39c39) + [Optionale Parameter für Dynamo angeben DBContext](#OptionalConfigParams) ## Erstellen MultiTable BatchGet Erstellt ein `MultiTableBatchGet`-Objekt, das aus verschiedenen einzelnen `BatchGet`-Objekten besteht. Jedes dieser `BatchGet`-Objekte kann verwendet werden, um Elemente aus einer einzelnen DynamoDB-Tabelle abzurufen. Um die Elemente aus Tabellen abzurufen, verwenden Sie die Methode `ExecuteBatchGet`, indem Sie das `MultiTableBatchGet`-Objekt als Parameter übergeben. ## Erschaffen MultiTable BatchWrite Erstellt ein `MultiTableBatchWrite`-Objekt, das aus verschiedenen einzelnen `BatchWrite`-Objekten besteht. Jedes dieser `BatchWrite`-Objekte kann für das Schreiben und das Löschen von Elementen in einer einzelnen DynamoDB-Tabelle verwendet werden. Um zu Tabellen zu schreiben, verwenden Sie die Methode `ExecuteBatchWrite`, indem Sie das `MultiTableBatchWrite`-Objekt als Parameter übergeben. ## CreateBatchGet Erstellt ein `BatchGet`-Objekt, welches für das Abrufen mehrerer Elemente aus einer Tabelle verwenden werden kann. ## CreateBatchWrite Erstellt ein `BatchWrite`-Objekt, das Sie zum Ablegen mehrerer Elemente in einer Tabelle oder zum Löschen mehrerer Elemente aus einer Tabelle verwenden können. ## Delete Löscht ein Element aus der Tabelle. Die Methode erfordert den Primärschlüssel des Elements, das Sie löschen möchten. Sie können entweder den Primärschlüsselwert oder ein clientseitiges Objekt bereitstellen, das einen Primärschlüsselwert als Parameter für diese Methode enthält. + Wenn Sie ein clientseitiges Objekt als Parameter angeben und die optimistische Sperre aktiviert haben, ist der Löschvorgang nur dann erfolgreich, wenn die clientseitigen und die serverseitigen Versionen des Objekts übereinstimmen. + Wenn Sie lediglich den Primärschlüsselwert als Parameter angeben, ist der Löschvorgang erfolgreich, unabhängig davon, ob die optimistische Sperre aktiv ist oder nicht. **Anmerkung** Um diese Operation im Hintergrund auszuführen, nutzen Sie stattdessen die `DeleteAsync`-Methode. ## Dispose Entsorgt alle verwalteten und nicht verwalteten Ressourcen. ## ExecuteBatchGet Liest Daten aus einer oder mehreren Tabellen und verarbeitet alle `BatchGet`-Objekte in einem `MultiTableBatchGet`. **Anmerkung** Um diese Operation im Hintergrund auszuführen, nutzen Sie stattdessen die `ExecuteBatchGetAsync`-Methode. ## ExecuteBatchWrite Liest oder löscht Daten aus einer oder mehreren Tabellen und verarbeitet alle `BatchWrite`-Objekte in einem `MultiTableBatchWrite`. **Anmerkung** Um diese Operation im Hintergrund auszuführen, nutzen Sie stattdessen die `ExecuteBatchWriteAsync`-Methode. ## FromDocument Angesichts einer `Document`-Instance, gibt die `FromDocument`-Methode eine Instance der clientseitigen Klasse zurück. Dies ist hilfreich, wenn Sie die Dokumentenmodell-Klassen zusammen mit dem Object Persistence-Modell verwenden möchten, um beliebige Datenoperationen durchzuführen. Weitere Hinweise zu den von der bereitgestellten Dokumentmodellklassen finden Sie unter[Arbeiten dem .NET-Dokumentmodell in DynamoDB](DotNetSDKMidLevel.md). AWS SDK für .NET Angenommen, Sie besitzen ein `Document`-Objekt mit dem Namen `doc`, das eine Darstellung eines `Forum`-Elements enthält. (Informationen zum Konstruieren dieses Objekts finden Sie in der Beschreibung der Methode `ToDocument` weiter unten in diesem Thema.) Sie können `FromDocument` verwenden, um das `Forum`-Element aus dem `Document` abzurufen, wie im folgendem C\$1-Codebeispiel gezeigt. **Example** ``` forum101 = context.FromDocument(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 Führt eine `Query`-Operation mit den Abfrageparametern aus, die in einem `QueryOperationConfig`-Objekt definiert sind. **Anmerkung** Um diese Operation im Hintergrund auszuführen, nutzen Sie stattdessen die `FromQueryAsync`-Methode. ## FromScan Führt eine `Scan`-Operation mit den Scan-Parametern aus, die in einem `ScanOperationConfig`-Objekt definiert sind. **Anmerkung** Um diese Operation im Hintergrund auszuführen, nutzen Sie stattdessen die `FromScanAsync`-Methode. ## GetTargetTable Ruft die Zieltabelle für den angegebenen Typ ab. Dies ist nützlich, wenn Sie einen benutzerdefinierten Konverter schreiben, der einer DynamoDB-Tabelle beliebige Daten zuordnet, und ermitteln müssen, welche Tabelle einem benutzerdefinierten Datentyp zugeordnet ist. ## Load Ruft ein Element aus einer Tabelle ab. Die Methode erfordert lediglich den Primärschlüssel des Elements, das Sie abrufen möchten. Standardmäßig gibt DynamoDB das Element mit Werten die Eventually Consistent sind zurück. Weitere Informationen zum Eventual Consistency-Modell finden Sie unter [DynamoDB-Lesekonsistenz](HowItWorks.ReadConsistency.md). `Load`oder `LoadAsync` Methode ruft den [GetItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_GetItem.html)Vorgang auf, bei dem Sie den Primärschlüssel für die Tabelle angeben müssen. Da der `IndexName`-Parameter von `GetItem` ignoriert wird, können Sie ein Element nicht mithilfe der Partition oder des Sortierschlüssels eines Indexes laden. Daher müssen Sie den Primärschlüssel der Tabelle verwenden, um ein Element zu laden. **Anmerkung** Um diese Operation im Hintergrund auszuführen, nutzen Sie stattdessen die `LoadAsync`-Methode. Ein Beispiel für die Verwendung der `LoadAsync`-Methode zur Ausführung von CRUD-Vorgängen auf hoher Ebene in einer DynamoDB-Tabelle finden Sie im Folgenden. ``` /// /// 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 Abfragen einer Tabelle basierend auf den Abfrageparametern, die Sie bereitstellen. Sie können eine Tabelle nur dann abfragen, wenn sie über einen zusammengesetzten Primärschlüssel verfügt (Partitionsschlüssel und Sortierschlüssel). Bei der Abfrage müssen Sie einen Partitionsschlüssel und eine Bedingung angeben, die für den Sortierschlüssel gilt. Angenommen, Sie verfügen über die clientseitige Klasse `Reply`, die der Tabelle `Reply` in DynamoDB zugeordnet ist. Das folgende C\$1-Codebeispiel fragt die Tabelle `Reply` ab, um alle Forum-Thread-Antworten zu finden, die in den letzten 15 Tagen veröffentlicht wurden. Die Tabelle `Reply` verfügt über einen Primärschlüssel, der aus einem Partitionsschlüssel (`Id`) und Sortierschlüssel (`ReplyDateTime`) besteht. **Example** ``` DynamoDBContext context = new DynamoDBContext(client); string replyId = "DynamoDB#DynamoDB Thread 1"; //Partition key DateTime twoWeeksAgoDate = DateTime.UtcNow.Subtract(new TimeSpan(14, 0, 0, 0)); // Date to compare. IEnumerable 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 Speichert das angegebene Objekt in der Tabelle. Wenn der im Eingabeobjekt angegebene Primärschlüssel in der Tabelle nicht vorhanden ist, fügt die Methode der Tabelle ein neues Element hinzu. Wenn der Primärschlüssel vorhanden ist, aktualisiert die Methode das vorhandene Element. Wenn Sie eine optimistische Sperre konfiguriert haben, ist die Aktualisierung nur dann erfolgreich, wenn die client- und serverseitigen Versionen des Elements übereinstimmen. Weitere Informationen finden Sie unter [Optimistisches Sperren mit DynamoDB und dem AWS SDK für .NET Objektpersistenzmodell](DynamoDBContext.VersionSupport.md). **Anmerkung** Um diese Operation im Hintergrund auszuführen, nutzen Sie stattdessen die `SaveAsync`-Methode. ## Scan Führt einen gesamten Tabellen-Scan durch. Sie können Scan-Ergebnisse filtern, indem Sie eine Scan-Bedingung angeben. Die Bedingung kann auf jedem Attribut in der Tabelle ausgewertet werden. Angenommen, Sie verfügen über die clientseitige Klasse `Book`, die der Tabelle `ProductCatalog` in DynamoDB zugeordnet ist. Im folgenden C\$1-Beispiel werden die Tabelle gescannt und ausschließlich die Book-Elemente zurückgegeben, deren Preis kleiner als 0 ist. **Example** ``` IEnumerable 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 Gibt eine Instance der `Document`-Dokumentenmodell-Klasse aus Ihrer Klassen-Instance zurück. Dies ist hilfreich, wenn Sie die Dokumentenmodell-Klassen zusammen mit dem Object Persistence-Modell verwenden möchten, um beliebige Datenoperationen durchzuführen. Weitere Hinweise zu den von der bereitgestellten Dokumentmodellklassen finden Sie unter[Arbeiten dem .NET-Dokumentmodell in DynamoDB](DotNetSDKMidLevel.md). AWS SDK für .NET Angenommen, Sie verfügen über eine clientseitige Klasse, die der Tabelle `Forum` zugeordnet ist. Sie können anschließend einen `DynamoDBContext` verwenden, um ein Element als `Document`-Objekt aus der Tabelle `Forum` abzurufen, wie im folgenden C\$1-Codebeispiel gezeigt. **Example** ``` DynamoDBContext context = new DynamoDBContext(client); Forum forum101 = context.Load(101); // Retrieve a forum by primary key. Document doc = context.ToDocument(forum101); ``` ## Optionale Parameter für Dynamo angeben DBContext Wenn Sie das Object Persistence-Modell verwenden, können Sie für den `DynamoDBContext` folgende optionale Parameter angeben. + **`ConsistentRead` – **Beim Abrufen von Daten mithilfe der `Load`, `Query` oder `Scan`-Operation können Sie diesen Parameter optional hinzufügen, um die neuesten Werte der Daten anzufordern. + **`IgnoreNullValues` – **Dieser Parameter teilt `DynamoDBContext` mit, Null-Werte von Attributen während einer `Save`-Operation zu ignorieren. Wenn dieser Parameter „false“ oder nicht festgelegt ist, wird ein Nullwert als Anweisung interpretiert, das betreffende Attribut zu löschen. + **`SkipVersionCheck`—** Dieser Parameter teilt `DynamoDBContext` mit, beim Speichern oder Löschen von Elementen keine Versionen zu vergleichen. Weitere Informationen über das Versioning finden Sie unter [Optimistisches Sperren mit DynamoDB und dem AWS SDK für .NET Objektpersistenzmodell](DynamoDBContext.VersionSupport.md). + **`TableNamePrefix` – ** Stellt allen Tabellennamen eine bestimmte Zeichenfolge voran. Wenn dieser Parameter Null ist (oder nicht festgelegt ist), dann wird kein Präfix verwendet. + `DynamoDBEntryConversion` – Gibt das Konvertierungsschema an, das vom Client verwendet wird. Sie können diesen Parameter auf Version V1 oder V2 festlegen. V1 ist die Standardversion. Je nach der von Ihnen festgelegten Version ändert sich das Verhalten dieses Parameters. Beispiel: + In V1 wird der Datentyp `bool` in den Zahlentyp `N` konvertiert, wobei 0 für falsch und 1 für wahr steht. In V2 wird `bool` in `BOOL` konvertiert. + In V2 werden Listen und Arrays nicht zusammen mit gruppiert. HashSets Listen und Arrays mit numerischen, auf Zeichenketten basierenden Typen und binären Typen werden in den Typ `L` (List) konvertiert, der leer gesendet werden kann, um eine Liste zu aktualisieren. Dies ist anders als bei V1, wo das Senden einer leeren Liste nicht möglich ist. In V1 werden Sammlungstypen wie List und Arrays gleich behandelt. HashSet Liste und HashSet Array von Zahlen werden in den Typ `NS` (Zahlensatz) konvertiert. Im folgenden Beispiel wird die Version des Konvertierungsschemas auf V2 festgelegt, wodurch das Konvertierungsverhalten zwischen .NET-Typen und DynamoDB-Datentypen geändert wird. ``` var config = new DynamoDBContextConfig { Conversion = DynamoDBEntryConversion.V2 }; var contextV2 = new DynamoDBContext(client, config); ``` Im folgenden C\$1-Codebeispiel wird durch Angabe von zwei der vorherigen optionalen Parameter, `ConsistentRead` und `SkipVersionCheck`, ein neuer Parameter `DynamoDBContext` erstellt. **Example** ``` AmazonDynamoDBClient client = new AmazonDynamoDBClient(); ... DynamoDBContext context = new DynamoDBContext(client, new DynamoDBContextConfig { ConsistentRead = true, SkipVersionCheck = true}); ``` `DynamoDBContext` berücksichtigt diese optionalen Parameter bei jeder Anforderung, die unter Verwendung dieses Kontextes gesendet werden. Anstatt diese Parameter auf der `DynamoDBContext`-Ebene festzulegen, können Sie diese mithilfe von `DynamoDBContext` für einzelne von Ihnen ausgeführte Operationen festlegen, wie im folgenden C\$1-Codebeispiel gezeigt. Das Beispiel lädt ein bestimmtes Book-Element. Die `Load`-Methode von `DynamoDBContext` gibt die optionalen Parameter `ConsistentRead` und `SkipVersionCheck` an. **Example** ``` AmazonDynamoDBClient client = new AmazonDynamoDBClient(); ... DynamoDBContext context = new DynamoDBContext(client); Book bookItem = context.Load(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 Die Unterstützung der optimistischen Sperre im Object Persistence-Modell stellt sicher, dass die Elementversion für Ihre Anwendung dieselbe ist wie die serverseitige Elementversion, bevor das Element aktualisiert oder gelöscht wird. Angenommen, Sie rufen ein Element für eine Aktualisierung ab. Bevor Sie jedoch Ihre Aktualisierungen zurücksenden, aktualisiert eine andere Anwendung das gleiche Element. Jetzt verfügt Ihre Anwendung über eine veraltete Kopie des Elements. Ohne optimistische Sperre wird jede von Ihnen durchgeführte Aktualisierung die Aktualisierung von anderen Anwendungen überschreiben. Die Funktion "optimistische Sperre" des Object Persistence-Modells stellt den `DynamoDBVersion`-Tag bereit, den Sie für die Aktivierung der optimistische Sperre nutzen können. Um diese Funktion zu verwenden, fügen Sie Ihrer Klasse eine Eigenschaft hinzu, mit der die Versionsnummer gespeichert wird. Sie fügen der Eigenschaft das Attribut `DynamoDBVersion` hinzu. Wenn Sie das Element zum ersten Mal speichern, weist `DynamoDBContext` diesem eine Versionsnummer hinzu. Dieser Wert wird bei jeder Aktualisierung des Elements inkrementell erhöht. Ihre Aktualisierungs- oder Löschanforderungen werden nur erfolgreich ausgeführt, wenn die clientseitige Objektversion mit der entsprechenden Versionsnummer des Elements auf der Serverseite übereinstimmt. Wenn Ihre Anwendung über eine veraltete Kopie verfügt, muss sie die aktuelle Version vom Server erhalten, bevor sie das Element aktualisieren oder löschen kann. Im folgenden C\$1-Codebeispiel wird die Klasse `Book` mit Object Persistence-Attributen definiert, die diese der Tabelle `ProductCatalog` zuordnen. Die Eigenschaft `VersionNumber` in der Klasse, die das `DynamoDBVersion`-Attribut aufweist, speichert den Wert der Versionsnummer. **Example** ``` [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; } [DynamoDBProperty("Authors")] public List 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 Um die optimistische Sperre zu deaktivieren, verwenden Sie die Konfigurationseigenschaft `SkipVersionCheck`. Sie können diese Eigenschaft bei der Erstellung von `DynamoDBContext` festlegen. In diesem Fall wird die optimistische Sperre für alle Anforderungen deaktiviert, die Sie unter Verwendung des Kontextes ausführen. Weitere Informationen finden Sie unter [Optionale Parameter für Dynamo angeben DBContext](DotNetDynamoDBContext.md#OptionalConfigParams). Anstatt die Eigenschaft auf der Kontextebene festzulegen, können Sie die optimistische Sperre für eine bestimmte Operation deaktivieren wie im folgenden C\$1-Codebeispiel gezeigt. Im Beispiel wird der Kontext verwendet, um ein Book-Element zu löschen. Die Methode `Delete` legt die optionale Eigenschaft `SkipVersionCheck` auf „true“ fest und deaktiviert damit die Versionsprüfung. **Example** ``` DynamoDBContext context = new DynamoDBContext(client); // Load a book. Book book = context.Load(111); ... // Delete the book. context.Delete(book, new DynamoDBContextConfig { SkipVersionCheck = true }); ``` # Zuordnen beliebiger Daten mit DynamoDB mithilfe des AWS SDK für .NET Objektpersistenzmodells Zusätzlich zu den unterstützten .NET-Typen (siehe [Unterstützte Datentypen](DotNetSDKHighLevel.md#DotNetDynamoDBContext.SupportedTypes)) können Sie Typen in Ihrer Anwendung verwenden, für die es kein direktes Mapping zu Amazon-DynamoDB-Typen gibt. Das Object-Persistence-Modell unterstützt das Speichern von Daten mit beliebigen Typen, solange Sie einen Konverter bereitstellen, um Daten des beliebigen Typs in den DynamoDB-Typ und umgekehrt zu konvertieren. Der Konverter-Code wandelt Daten während des Speicherns und Ladens der Objekte um. Sie können clientseitig alle Typen erstellen. Die in den Tabellen gespeicherten Daten haben jedoch einen DynamoDB-Datentyp. Während Abfragen und Scans werden alle Datenvergleiche anhand der in DynamoDB gespeicherten Daten ausgeführt. Das folgende C\$1-Codebeispiel definiert eine `Book`-Klasse mit den Eigenschaften `Id`, `Title`, `ISBN` und `Dimension`. Die Eigenschaft `Dimension` gehört zum `DimensionType`, der die Eigenschaften `Height`, `Width` und `Thickness` beschreibt. Der Beispielcode stellt die Konverter-Methoden `ToEntry` und `FromEntry` bereit, um Daten zwischen den Zeichenfolgetypen `DimensionType` und DynamoDB zu konvertieren. Beispielsweise erstellt der Konverter beim Speichern einer `Book`-Instance eine `Dimension`-Zeichenfolge wie „8.5x11x.05“. Wenn Sie ein Book abrufen, wird die Zeichenfolge in eine `DimensionType`-Instance konvertiert. Im Beispiel wird der `Book`-Typ der Tabelle `ProductCatalog` zugewiesen. Es speichert eine `Book`-Beispiel-Instance, ruft sie ab, aktualisiert ihre Abmessungen und speichert die aktualisierte `Book`-Instance erneut. step-by-stepAnweisungen zum Testen des folgenden Beispiels finden Sie unter. [.NET-Codebeispiele](CodeSamples.DotNet.md) **Example** ``` using System; using System.Collections.Generic; using Amazon.DynamoDBv2; using Amazon.DynamoDBv2.DataModel; using Amazon.DynamoDBv2.DocumentModel; using Amazon.Runtime; using Amazon.SecurityToken; namespace com.amazonaws.codesamples { class HighLevelMappingArbitraryData { private static AmazonDynamoDBClient client = new AmazonDynamoDBClient(); static void Main(string[] args) { try { DynamoDBContext context = new DynamoDBContext(client); // 1. Create a book. DimensionType myBookDimensions = new DimensionType() { Length = 8M, Height = 11M, Thickness = 0.5M }; Book myBook = new Book { Id = 501, Title = "AWS SDK for .NET Object Persistence Model Handling Arbitrary Data", ISBN = "999-9999999999", BookAuthors = new List { "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; } } } ```