La AWS SDK pour .NET V3 est passée en mode maintenance. Nous vous recommandons de migrer vers la version [AWS SDK pour .NET V4](https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/welcome.html). Pour plus de détails et d'informations sur la façon de migrer, veuillez consulter notre [annonce relative au mode de maintenance](https://aws.amazon.com/blogs/developer/aws-sdk-for-net-v3-maintenance-mode-announcement/). 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 **Note** Les modèles de programmation décrits dans ces rubriques sont présents à la fois dans .NET Framework et .NET (Core), mais les conventions d'appel diffèrent, qu'elles soient synchrones ou asynchrones. Il AWS SDK pour .NET prend en charge Amazon DynamoDB, un service de base de données NoSQL rapide proposé par. AWS*Le 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 les leurs APIs, 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 pour .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 noms [Amazon.Dynamo. DBv2](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/DynamoDBv2/NDynamoDBv2.html) 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 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); } ``` ### 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 { { "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); ``` ## 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 par le biais d'[Amazon.Dynamo. DBv2 DocumentModel](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/DynamoDBv2/NDynamoDBv2DocumentModel.html)espace 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](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DotNetSDKMidLevel.html) manuel Amazon [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/) 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 [https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/DynamoDBv2/TTable.html](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/DynamoDBv2/TTable.html)classe, comme dans l'exemple suivant : ``` var client = new AmazonDynamoDBClient(); Table table = Table.LoadTable(client, "Reply"); ``` **Note** Bien que ce mécanisme fonctionne, dans certaines conditions, il peut parfois entraîner une latence supplémentaire ou des blocages en raison des comportements de démarrage à froid et de pool de threads. Pour plus d'informations sur ces comportements, consultez le billet de blog Modèles d'[initialisation DynamoDB améliorés](https://aws.amazon.com/blogs/developer/improved-dynamodb-initialization-patterns-for-the-aws-sdk-for-net/) pour le. AWS SDK pour .NET **TableBuilder** Un mécanisme alternatif, la [https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/DynamoDBv2/TTableBuilder.html](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/DynamoDBv2/TTableBuilder.html)classe, a été introduit dans la [version 3.7.203 du package AWSSDK DBv2 NuGet .Dynamo](https://www.nuget.org/packages/AWSSDK.DynamoDBv2/3.7.203). 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](https://aws.amazon.com/blogs/developer/improved-dynamodb-initialization-patterns-for-the-aws-sdk-for-net/) pour le. AWS SDK pour .NET ### Insertion d'un élément dans un tableau Dans l'exemple suivant, une réponse est insérée dans le tableau des réponses par le biais de 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 le stockage, le chargement et l'interrogation d'objets .NET dans DynamoDB. Vous pouvez accéder à ce modèle par le biais d'[Amazon.Dynamo. DBv2 DataModel](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/DynamoDBv2/NDynamoDBv2DataModel.html)espace 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](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DotNetSDKHighLevel.html) dans le manuel Amazon [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/) 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'`DynamoDBTable`attribut 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'`DynamoDBGlobalSecondaryIndexHashKey`attribut 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. `DisableFetchingTableMetadata`Il est défini sur`true`, 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. **Note** Dans certaines conditions, les appels à la `DescribeTable` méthode peuvent parfois entraîner une latence supplémentaire ou des blocages en raison des comportements de démarrage à froid et de pool de threads. Pour cette raison, il est parfois avantageux d'éviter d'avoir recours à cette méthode. Pour plus d'informations sur ces comportements, consultez le billet de blog Modèles d'[initialisation DynamoDB améliorés](https://aws.amazon.com/blogs/developer/improved-dynamodb-initialization-patterns-for-the-aws-sdk-for-net/) pour le. AWS SDK pour .NET ### 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, 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("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ée`DisableFetchingTableMetadata`. Cette propriété, qui a été introduite dans la [version 3.7.203 du DBv2 NuGet package AWSSDK .Dynamo](https://www.nuget.org/packages/AWSSDK.DynamoDBv2/3.7.203), 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](https://aws.amazon.com/blogs/developer/improved-dynamodb-initialization-patterns-for-the-aws-sdk-for-net/) pour le. AWS SDK pour .NET Vous trouverez ci-dessous des informations supplémentaires sur cette propriété. + Cette propriété peut être définie globalement dans votre `web.config` fichier `app.config` or si vous utilisez .NET Framework. + Cette propriété peut être définie globalement à l'aide de la [https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Amazon/TAWSConfigsDynamoDB.html](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Amazon/TAWSConfigsDynamoDB.html)classe, comme illustré dans l'exemple suivant. ``` // Set the DisableFetchingTableMetadata property globally // before constructing any context objects. AWSConfigsDynamoDB.Context.DisableFetchingTableMetadata = true; var client = new AmazonDynamoDBClient(); var context = new DynamoDBContext(client); ``` + Dans certains cas, vous ne pouvez pas ajouter d'attributs DynamoDB à une classe .NET, par exemple si la classe est définie dans une dépendance. Dans de tels cas, il est toujours possible de profiter de la `DisableFetchingTableMetadata` propriété. Pour ce faire, utilisez la [https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/DynamoDBv2/TTableBuilder.html](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/DynamoDBv2/TTableBuilder.html)classe en plus de la `DisableFetchingTableMetadata` propriété. La `TableBuilder` classe a également été introduite dans la [version 3.7.203 du package AWSSDK .Dynamo. DBv2 NuGet ](https://www.nuget.org/packages/AWSSDK.DynamoDBv2/3.7.203) ``` // 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" }); ``` ## En savoir plus **Utilisation du AWS SDK pour .NET pour programmer DynamoDB, informations et exemples** + [DynamoDB APIs](http://blogs.aws.amazon.com/net/post/Tx17SQHVEMW8MXC/DynamoDB-APIs) + [Lancement de DynamoDB Series](http://blogs.aws.amazon.com/net/post/Tx2XQOCY08QMTKO/DynamoDB-Series-Kickoff) + [DynamoDB Series - Modèle de document](http://blogs.aws.amazon.com/net/post/Tx2R0WG46GQI1JI/DynamoDB-Series-Document-Model) + [DynamoDB Series - Schémas de conversion](http://blogs.aws.amazon.com/net/post/Tx2TCOGWG7ARUH5/DynamoDB-Series-Conversion-Schemas) + [DynamoDB Series - Modèle de persistance des objets](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) + [Utilisation d'expressions avec Amazon DynamoDB et le AWS SDK pour .NET](dynamodb-expressions.md) + [Support JSON dans Amazon DynamoDB](dynamodb-json.md) **Modèle de bas niveau, informations et exemples** + [Utilisation de tables à l'aide de l'API de AWS SDK pour .NET bas niveau](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LowLevelDotNetWorkingWithTables.html) + [Utilisation d'éléments à l'aide de l'API de AWS SDK pour .NET bas niveau](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LowLevelDotNetItemCRUD.html) + [Interrogation de tables à l'aide de l'API de AWS SDK pour .NET bas niveau](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LowLevelDotNetQuerying.html) + [Numérisation de tables à l'aide de l' AWS SDK pour .NET API de bas niveau](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LowLevelDotNetScanning.html) + [Utilisation d'index secondaires locaux à l'aide de l'API de AWS SDK pour .NET bas niveau](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LSILowLevelDotNet.html) + [Utilisation d'index secondaires globaux à l'aide de l'API de AWS SDK pour .NET bas niveau](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GSILowLevelDotNet.html) **Modèle de document, informations et exemples** + [Types de données DynamoDB](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 : Modèle de document](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DotNetSDKMidLevel.html) **Modèle de persistance des objets, informations et exemples** + [.NET : modèle de persistance des objets](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DotNetSDKHighLevel.html) **Autres informations utiles** + Consultez [Intégration AWS à .NET Aspire](aspire-integrations.md) pour plus d'informations sur le développement avec Amazon DynamoDB local via .NET Aspire. **Topics** + [Modèle de bas niveau](#dynamodb-intro-apis-low-level) + [Modèle de document](#dynamodb-intro-apis-document) + [Modèle de persistance des objets](#dynamodb-intro-apis-object-persistence) + [En savoir plus](#dynamodb-intro-more-info) + [Utilisation d’expressions](dynamodb-expressions.md) + [Prise en charge JSON](dynamodb-json.md)