Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Utilisation des bases de données NoSQL Amazon DynamoDB

Il AWS SDK for .NET prend en charge Amazon DynamoDB, un service de base de données NoSQL rapide proposé par. AWSLe SDK fournit trois modèles de programmation pour communiquer avec DynamoDB : le modèle de bas niveau, le modèle de document et le modèle de persistance des objets.

Les informations suivantes présentent ces modèles et leurs API, fournissent des exemples expliquant comment et quand les utiliser, et vous proposent des liens vers des ressources de programmation DynamoDB supplémentaires dans le. AWS SDK for .NET

Modèle de bas niveau

Le modèle de programmation de bas niveau englobe les appels directs au service DynamoDB. Vous pouvez accéder à ce modèle via l'espace de nom Amazon.DynamoDBv2.

Parmi les trois modèles, le modèle de bas niveau est celui qui nécessite le plus de programmation. Par exemple, vous devez convertir les types de données .NET en leurs équivalents dans DynamoDB. Toutefois, ce modèle donne accès à la plupart des fonctions.

Les exemples suivants montrent comment utiliser le modèle de bas niveau pour créer une table, modifier une table et insérer des éléments dans une table dans DynamoDB.

Création d'une table

L'exemple suivant utilise la méthode CreateTable de la classe AmazonDynamoDBClient pour créer une table. La méthode CreateTable utilise une instance de la classe CreateTableRequest, qui contient des caractéristiques telles que des noms d'attribut d'élément requis, une définition de clé primaire et une capacité de débit. La méthode CreateTable renvoie une instance de la classe CreateTableResponse.

// 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);
}

Vérification qu'une table est prête pour modification

Pour pouvoir remplacer ou modifier une table, celle-ci doit être prête pour cette opération. L'exemple suivant montre comment utiliser le modèle de bas niveau pour vérifier qu'une table est prête dans DynamoDB. Dans cet exemple, la table cible à vérifier est référencée par l'intermédiaire de la méthode DescribeTable de la classe AmazonDynamoDBClient. Toutes les cinq secondes, le code vérifie la valeur de la propriété TableStatus de la table. Lorsque le statut est défini sur ACTIVE, la table est prête à être modifiée.

// 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);

Insertion d'un élément dans une table

Dans l'exemple suivant, vous utilisez le modèle de bas niveau pour insérer deux éléments dans une table de DynamoDB. Chaque élément est inséré par l'intermédiaire de la méthode PutItem de la classe AmazonDynamoDBClient, en utilisant une instance de la classe PutItemRequest. Chacune des deux instances de la classe PutItemRequest prend le nom de la table dans laquelle les éléments seront insérés, avec une série de valeurs d'attribut d'élément.

// 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);

Modèle de document

Le modèle de programmation de documents permet de travailler plus facilement avec les données dans DynamoDB. Ce modèle est particulièrement conçu pour l'accès aux tables et aux éléments des tables. Vous pouvez accéder à ce modèle via Amazon.DynamoDBV2. DocumentModelespace de noms.

Comparé au modèle de programmation de bas niveau, le modèle de document est plus facile à coder à partir des données DynamoDB. Par exemple, il n'est pas nécessaire de convertir autant de types de données .NET en leurs équivalents dans DynamoDB. Toutefois, ce modèle ne donne pas accès à autant de fonctions que le modèle de programmation de bas niveau. Par exemple, vous pouvez utiliser ce modèle pour créer, extraire, mettre à jour et supprimer des éléments dans des tables. Toutefois, pour créer les tables, vous devez utiliser le modèle de bas niveau. Comparé au modèle de persistance des objets, ce modèle nécessite davantage de programmation pour stocker, charger et interroger des objets .NET.

Pour plus d'informations sur le modèle de programmation de documents DynamoDB, consultez .NET : modèle de document dans le manuel Amazon DynamoDB Developer Guide.

Les sections suivantes fournissent des informations sur la création d'une représentation de la table DynamoDB souhaitée, ainsi que des exemples sur la manière d'utiliser le modèle de document pour insérer des éléments dans des tableaux et obtenir des éléments à partir de tableaux.

Création d'une représentation de la table

Pour effectuer des opérations sur les données à l'aide du modèle de document, vous devez d'abord créer une instance de la Table classe qui représente une table spécifique. Il existe deux méthodes principales pour ce faire.

LoadTable méthode

Le premier mécanisme consiste à utiliser l'une des LoadTable méthodes statiques de la Tableclasse, comme dans l'exemple suivant :

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

TableBuilder

Un mécanisme alternatif, la TableBuilderclasse, a été introduit dans la version 3.7.203 du package AWSSDK NuGet .DynamoDBv2. Ce mécanisme peut remédier aux comportements mentionnés ci-dessus en supprimant certains appels de méthode implicites, en particulier la DescribeTable méthode. Ce mécanisme est utilisé de la même manière que dans l'exemple suivant :

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();

Pour plus d'informations sur ce mécanisme alternatif, consultez à nouveau le billet de blog Modèles d'initialisation DynamoDB améliorés pour le. AWS SDK for .NET

Insertion d'un élément dans un tableau

Dans l'exemple suivant, une réponse est insérée dans la table Reply via la PutItemAsync méthode de la Table classe. La méthode PutItemAsync prend une instance de la classe Document ; la classe Document est simplement une collection d'attributs initialisés.

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);

Obtenir un élément d'une table

Dans l'exemple suivant, une réponse est récupérée par le biais de la GetItemAsync méthode de la Table classe. Pour déterminer la réponse à obtenir, la GetItemAsync méthode utilise la clé hash-and-range primaire de la réponse cible.

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"]);

L'exemple précédent convertit implicitement les valeurs de table en chaînes pour la WriteLine méthode. Vous pouvez effectuer des conversions explicites en utilisant les différentes méthodes « As [type] » de la DynamoDBEntry classe. Par exemple, vous pouvez convertir explicitement la valeur d'un type Id de Primitive données en GUID par le biais de la AsGuid() méthode suivante :

var guid = reply["Id"].AsGuid();

Modèle de persistance des objets

Le modèle de programmation de persistance des objets est spécialement conçu pour stocker, charger et interroger des objets .NET dans DynamoDB. Vous pouvez accéder à ce modèle via Amazon.DynamoDBV2. DataModelespace de noms.

Parmi les trois modèles, le modèle de persistance des objets est le plus facile à utiliser pour coder lorsque vous stockez, chargez ou interrogez des données DynamoDB. Par exemple, vous travaillez directement avec les types de données DynamoDB. Toutefois, ce modèle permet d'accéder uniquement aux opérations qui stockent, chargent et interrogent des objets .NET dans DynamoDB. Par exemple, vous pouvez utiliser ce modèle pour créer, extraire, mettre à jour et supprimer des éléments dans des tables. Toutefois, vous devez tout d'abord créer vos tables à l'aide du modèle de bas niveau, puis utiliser ce modèle pour mapper vos classes .NET avec les tables.

Pour plus d'informations sur le modèle de programmation de persistance des objets DynamoDB, consultez .NET : modèle de persistance des objets dans le manuel Amazon DynamoDB Developer Guide.

Les exemples suivants montrent comment définir une classe .NET qui représente un élément DynamoDB, utiliser une instance de la classe .NET pour insérer un élément dans une table DynamoDB et utiliser une instance de la classe .NET pour obtenir un élément de la table.

Définition d'une classe .NET qui représente un élément d'une table

Dans l'exemple suivant de définition de classe, l'DynamoDBTableattribut indique le nom de la table, tandis que les DynamoDBRangeKey attributs DynamoDBHashKey et modélisent la clé hash-and-range primaire de la table. L'DynamoDBGlobalSecondaryIndexHashKeyattribut est défini de telle sorte qu'une requête de réponses par un auteur spécifique puisse être créée.

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; }
}

Création d'un contexte pour le modèle de persistance des objets

Pour utiliser le modèle de programmation de persistance des objets pour DynamoDB, vous devez créer un contexte qui fournit une connexion à DynamoDB et vous permet d'accéder à des tables, d'effectuer diverses opérations et d'exécuter des requêtes.

Contexte de base

L'exemple suivant montre comment créer le contexte le plus élémentaire.

using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DataModel;

var client = new AmazonDynamoDBClient();
var context = new DynamoDBContext(client);

Contexte lié à DisableFetchingTableMetadata la propriété

L'exemple suivant montre comment vous pouvez également définir la DisableFetchingTableMetadata propriété de la DynamoDBContextConfig classe pour empêcher les appels implicites à la DescribeTable méthode.

using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DataModel;

var client = new AmazonDynamoDBClient();
var context = new DynamoDBContext(client, new DynamoDBContextConfig
{
    DisableFetchingTableMetadata = true
});

Si la DisableFetchingTableMetadata propriété est définie sur false (valeur par défaut), comme indiqué dans le premier exemple, vous pouvez omettre les attributs décrivant la structure de clé et d'index des éléments de table dans la Reply classe. Ces attributs seront plutôt déduits par un appel implicite à la DescribeTable méthode. DisableFetchingTableMetadataIl est défini surtrue, comme indiqué dans le deuxième exemple, sur les méthodes du modèle de persistance des objets telles que SaveAsync et QueryAsync s'appuyant entièrement sur les attributs définis dans la Reply classe. Dans ce cas, aucun appel à la DescribeTable méthode n'a lieu.

Utilisation d'une instance de la classe .NET pour insérer un élément dans un tableau

Dans cet exemple, un élément est inséré par le biais de la SaveAsync méthode de la DynamoDBContext classe, qui prend une instance initialisée de la classe .NET qui représente l'élément.

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"
});

Utilisation d'une instance d'une classe .NET pour obtenir des éléments d'une table

Dans cet exemple, une requête est créée pour trouver tous les enregistrements de « Author1" en utilisant la QueryAsync méthode de la DynamoDBContext classe. Ensuite, les éléments sont récupérés via la GetNextSetAsync méthode de la requête.

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);
}

Informations supplémentaires sur le modèle de persistance des objets

Les exemples et explications présentés ci-dessus incluent parfois une propriété de la DynamoDBContext classe appeléeDisableFetchingTableMetadata. Cette propriété, qui a été introduite dans la version 3.7.203 du NuGet package AWSSDK .DynamoDBv2, vous permet d'éviter certaines conditions susceptibles d'entraîner une latence ou des blocages supplémentaires en raison des comportements de démarrage à froid et de pool de threads. Pour plus d'informations, consultez le billet de blog Modèles d'initialisation DynamoDB améliorés pour le. AWS SDK for .NET

Vous trouverez ci-dessous des informations supplémentaires sur cette propriété.

En savoir plus

Utilisation du AWS SDK for .NET pour programmer des informations et des exemples DynamoDB**

Informations et exemples de modèle de bas niveau.

Informations et exemples de modèle de document

Informations et exemples sur le modèle de persistance des objets