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

Der AWS SDK for .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 Modelle und ihre APIs vor, enthalten Beispiele dafür, wie und wann sie verwendet werden sollten, und enthalten Links zu zusätzlichen DynamoDB-Programmierressourcen in der. AWS SDK for .NET

Low-Level-Modell

Das Low-Level-Programmiermodell umschließt direkte Aufrufe des DynamoDB-Dienstes. Sie greifen auf dieses Modell über den Amazon.DynamoDBv2-Namespace zu.

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<string> currentTables = client.ListTables().TableNames;
Console.WriteLine("Number of tables: " + currentTables.Count);
if (!currentTables.Contains("AnimalsInventory"))
{
    var request = new CreateTableRequest
    {
        TableName = "AnimalsInventory",
        AttributeDefinitions = new List<AttributeDefinition>
      {
        new AttributeDefinition
        {
          AttributeName = "Id",
          // "S" = string, "N" = number, and so on.
          AttributeType = "N"
        },
        new AttributeDefinition
        {
          AttributeName = "Type",
          AttributeType = "S"
        }
      },
        KeySchema = new List<KeySchemaElement>
      {
        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<string, AttributeValue>
  {
    { "Id", new AttributeValue { N = "1" }},
    { "Type", new AttributeValue { S = "Dog" }},
    { "Name", new AttributeValue { S = "Fido" }}
  }
};

var request2 = new PutItemRequest
{
  TableName = "AnimalsInventory",
  Item = new Dictionary<string, AttributeValue>
  {
    { "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.DynamoDBv2 auf dieses Modell zu. DocumentModelNamespace.

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 im Amazon DynamoDB 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 TableKlasse zu verwenden, ähnlich dem folgenden Beispiel:

var client = new AmazonDynamoDBClient();
Table table = Table.LoadTable(client, "Reply");

TableBuilder

Ein alternativer Mechanismus, die TableBuilderKlasse, wurde in Version 3.7.203 des .dynamoDBv2-Pakets eingeführt. AWSSDK 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 für die. AWS SDK for .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.DynamoDBv2 auf dieses Modell zu. DataModelNamespace.

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 im Amazon 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 isttrue, 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.

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>(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<Reply>("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 NuGet .dynamoDBv2-Pakets eingeführt wurde, ermöglicht es Ihnen, bestimmte Bedingungen zu vermeiden, die 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 für. AWS SDK for .NET

Im Folgenden finden Sie einige zusätzliche Informationen zu dieser Eigenschaft.

Weitere Informationen

Verwenden der AWS SDK for .NET DynamoDB-Informationen und -Beispiele**

Low-Level-Modell – Informationen und Beispiele

Dokument-Modell – Informationen und Beispiele

Informationen und Beispiele zum Modell der Objektpersistenz