Le SDK AWS mobile pour Xamarin est désormais inclus dans le. AWS SDK pour .NET Ce guide fait référence à la version archivée du SDK mobile pour Xamarin.
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.
# Amazon DynamoDB
## Qu’est-ce qu’Amazon DynamoDB ?
[Amazon DynamoDB](https://aws.amazon.com/dynamodb/) est un service de bases de données non relationnelles rapide et hautement évolutif. DynamoDB permet de s'affranchir des limites habituelles du dimensionnement de stockage de données, tout en conservant une faible latence et des performances prévisibles.
## Concepts clés
Les concepts de modèle de données DynamoDB incluent des tables, des éléments et des attributs.
### Tables
Dans Amazon DynamoDB, une base de données est un ensemble de tables. Une table est un ensemble d'éléments et chaque élément est un ensemble d'attributs.
Dans une base de données relationnelle, une table a un schéma prédéfini, tel que le nom de la table, la clé primaire, la liste des noms de colonnes et leurs types de données. Tous les enregistrements stockés dans la table doivent avoir le même ensemble de colonnes. En revanche, DynamoDB exige uniquement qu'une table ait une clé primaire, mais ne requiert pas que vous définissiez tous les noms d'attribut et les types de données à l'avance.
Pour en savoir plus sur l'utilisation des tables, consultez [Utilisation de tables dans DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.html).
### Eléments et attributs
Des éléments individuels dans une table DynamoDB peuvent avoir n'importe quel nombre d'attributs, bien qu'il y ait une limite de 400 Ko sur la taille d'élément. La taille d'un élément est la somme des longueurs de ses noms et valeurs d'attribut (longueurs binaire et UTF-8).
Chaque attribut dans un élément est une paire nom-valeur. Un attribut peut être un ensemble à valeur unique ou à plusieurs valeurs. Par exemple, un élément de livre peut avoir des attributs de titre et d'auteurs. Chaque livre a un titre mais peut avoir plusieurs auteurs. L'attribut à plusieurs valeurs est un ensemble ; les valeurs en double ne sont pas autorisées.
Par exemple, envisagez de stocker un catalogue de produits dans DynamoDB. Vous pouvez créer une table avec l'attribut Id comme clé primaire. ProductCatalog La clé primaire identifie de manière unique chaque élément de la table, de sorte que deux produits de la table ne peuvent pas avoir le même ID.
Pour en savoir plus sur l'utilisation des éléments, consultez [Utilisation des éléments dans DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html).
### Les types de données
Amazon DynamoDB prend en charge les types de données suivants :
+ **Types scalar** : Number, String, Binary, Boolean et Null.
+ **Types à valeurs multiples** : String Set, Number Set et Binary Set.
+ **Types document** : List et Map.
Pour plus d'informations sur les types de données scalar, à valeurs multiples et document, consultez la page [Types de données DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataModel.html#DataModel.DataTypes).
### Clé primaire
Lorsque vous créez une table, en plus du nom de la table, vous devez spécifier la clé primaire de la table. La clé primaire identifie de manière unique chaque élément de la table, afin qu’aucun deux éléments n’ait la même clé. DynamoDB prend en charge les deux types de clés primaires suivants :
+ **Clé de hachage** : la clé primaire est constituée d'un seul attribut, un attribut de hachage. DynamoDB crée un index de hachage non ordonné sur cet attribut de clé primaire. Chaque élément de la table est identifié de manière unique par sa valeur clé de hachage.
+ **Clé de hachage et de plage** : la clé primaire est constituée de deux attributs. Le premier est l'attribut de hachage et le second est l'attribut de plage. DynamoDB crée un index de hachage non ordonné sur l'attribut de clé primaire de hachage et un index de plage trié sur l'attribut de clé primaire de plage. Chaque élément de la table est identifié de manière unique par la combinaison de ses valeurs de clé de hachage et de plage. Il est possible pour deux éléments d'avoir la même valeur de clé de hachage, mais ces deux éléments doivent avoir des valeurs de clés de plage différentes.
### Index secondaires
Lorsque vous créez une table avec une clé de hachage et de plage, vous pouvez définir, le cas échéant, un ou plusieurs index secondaires sur cette table. Un index secondaire vous permet d’interroger les données de la table à l’aide d’une clé alternative, en plus des requêtes sur la clé primaire.
DynamoDB prend en charge deux types d'index secondaires : les index secondaires locaux et index secondaires globaux.
+ **Index secondaire local** : index ayant la même clé de hachage que la table, mais une clé de plage différente.
+ **Index secondaire global** : index avec une clé de hachage et une clé de plage qui peuvent être différentes de celles de la table.
Vous pouvez définir jusqu'à 5 index secondaires globaux et 5 index secondaires locaux par table. Pour plus d'informations sur ces index, consultez [Amélioration de l'accès aux données avec les index secondaires dans DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/SecondaryIndexes.html) dans le Manuel du développeur DynamoDB.
### Query and Scan
Outre l'utilisation de clés primaires pour accéder aux éléments, Amazon DynamoDB en fournit APIs deux pour rechercher les données : Query et Scan. Nous vous recommandons de lire [Bonnes pratiques concernant l'interrogation et l'analyse des données](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScanGuidelines.html) dans le Manuel du développeur DynamoDB pour vous familiariser avec quelques bonnes pratiques.
#### Query
Une opération Query recherche les éléments d'une table ou d'un index secondaire uniquement à l'aide des valeurs d'attribut de la clé primaire. Vous devez fournir un attribut de clé de hachage et une valeur distincte à rechercher. Vous pouvez, le cas échéant, fournir un attribut de clé de plage et une valeur, et utiliser un opérateur de comparaison pour affiner les résultats de recherche.
Pour des exemples de requêtes, consultez :
+ [Utilisation du modèle de document](dynamodb-integration-docmodel.md)
+ [Utilisation du modèle de persistance des objets](dynamodb-integration-objectpersistencemodel.md)
+ [Utilisation du niveau de service DynamoDB APIs](dynamodb-integration-lowlevelapi.md)
Pour plus d'informations sur l'interrogation des données, consultez la partie [Interrogation](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScan.html#QueryAndScan.Query) dans le Manuel du développeur DynamoDB.
#### Analyser
Une opération Scan lit tous les éléments d'une table ou d'un index secondaire. Par défaut, une opération Scan retourne tous les attributs de données pour chaque élément de la table ou de l'index. Vous pouvez utiliser le ProjectionExpression paramètre pour que Scan ne renvoie que certains attributs, plutôt que tous.
Pour des exemples d'analyses, consultez :
+ [Utilisation du modèle de document](dynamodb-integration-docmodel.md)
+ [Utilisation du modèle de persistance des objets](dynamodb-integration-objectpersistencemodel.md)
+ [Utilisation du niveau de service DynamoDB APIs](dynamodb-integration-lowlevelapi.md)
Pour plus d'informations sur l'analyse des données, consultez la partie [Analyse](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScan.html#QueryAndScan.Scan) dans le Manuel du développeur DynamoDB.
## Configuration du projet
### Conditions préalables
Pour utiliser DynamoDB dans votre application, vous devez ajouter le kit SDK à votre projet. Pour ce faire, suivez les instructions de la section [Configurer le kit SDK AWS Mobile pour .NET et Xamarin](setup.md).
### Créer une table DynamoDB
Pour créer une table, accédez à la [console DynamoDB](https://console.aws.amazon.com/dynamodb/home) et procédez comme suit :
1. Cliquez sur **Créer une table**.
1. Saisissez le nom de la table.
1. Sélectionnez **Hachage** comme type de clé primaire.
1. Sélectionnez un type et entrez une valeur pour le nom d'attribut de hachage. Cliquez sur **Continuer**.
1. Sur la page **Add Indexes (Ajouter des index)**, si vous prévoyez d'utiliser des index secondaires globaux, spécifiez Global Secondary Index pour **Index Type (Type d'index)** et sous **Index Hash Key (Clé de hâchage d'index)**, saisissez une valeur pour l'index secondaire. Cela vous permettra d'effectuer une interrogation et une analyse à l'aide de l'index principal et de l'index secondaire. Cliquez sur **Add Index To Table (Ajouter l'index à la table)**, puis sur **Continue (Continuer)**. Pour ne pas utiliser d'index secondaires globaux, cliquez sur **Continue (Continuer)**.
1. Définissez la capacité de lecture et d'écriture aux niveaux souhaités. Pour plus d'informations sur la configuration de la capacité, consultez [Débit alloué dans Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ProvisionedThroughputIntro.html). Cliquez sur **Continuer**.
1. Dans l'écran suivant, entrez un e-mail de notification afin de créer des alarmes relatives au débit, si vous le souhaitez. Cliquez sur **Continuer**.
1. Sur la page récapitulative, cliquez sur **Create (Créer)**. DynamoDB crée alors votre base de données.
### Définir les autorisations pour DynamoDB
Pour utiliser DynamoDB dans une application, vous devez définir les autorisations appropriées. La stratégie IAM suivante permet à l'utilisateur de supprimer, d'obtenir, de placer, d'interroger, d'analyser et de mettre à jour des éléments dans une table DynamoDB qui est identifiée par son [ARN](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) :
```
{
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:DeleteItem",
"dynamodb:GetItem",
"dynamodb:PutItem",
"dynamodb:Query",
"dynamodb:Scan",
"dynamodb:UpdateItem"
],
"Resource": "arn:aws:dynamodb:us-west-2:123456789012:table/MyTable"
}
]
}
```
Vous pouvez modifier les stratégies dans la [console IAM](https://console.aws.amazon.com/iam/). Ajoutez ou supprimez ensuite des actions autorisées selon les besoins de votre application.
Pour plus d'informations sur les stratégies IAM, consultez [Utilisation d'IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/IAM_Introduction.html).
Pour en savoir plus sur les stratégies spécifiques à DynamoDB, consultez [Utilisation d'IAM pour contrôler l'accès aux ressources DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/UsingIAMWithDDB.html) dans le Manuel du développeur DynamoDB.
## Intégration de DynamoDB avec votre application
Le kit SDK AWS Mobile pour .NET and Xamarin fournit une bibliothèque de haut niveau permettant de travailler avec DynamoDB. Vous pouvez également envoyer des requêtes directement à l'API DynamoDB de bas niveau, mais pour la plupart des cas d'utilisation, il est recommandée d'utiliser la bibliothèque de haut niveau. AmazonDynamoDBClient Il s'agit d'une partie particulièrement utile de la bibliothèque de haut niveau. Cette classe vous permet d'effectuer diverses opérations de création, de lecture, de mise à jour et de suppression, et d'exécuter des requêtes.
Le SDK AWS Mobile pour .NET and Xamarin vous permet de passer des appels en utilisant le SDK AWS pour .NET afin APIs de fonctionner avec DynamoDB. Ils APIs sont tous disponibles dans le AWSSDK fichier .dll. Pour plus d'informations sur le téléchargement du kit SDK AWS pour .NET, consultez [Kit AWS SDK pour .NET](https://aws.amazon.com/sdk-for-net/).
Il existe trois façons d'interagir avec DynamoDB dans votre application Xamarin :
+ **Modèle de document** : cette API fournit des classes wrapper autour de l'API de bas niveau DyanmoDB pour simplifier vos tâches de programmation. Table et Document sont les classes d'enveloppe principales. Vous pouvez utiliser le modèle de document pour les opérations de données telles que créer, extraire, mettre à jour et supprimer des éléments. L'API est disponible dans le fichier Amazon.DynamoDB. DocumentModel espace de noms.
+ **Modèle de persistance des objets** : l'API Object Persistence vous permet de mapper vos classes côté client avec les tables DynamoDB. Ensuite, chaque instance d’objet est mappée à un élément des tables correspondantes. La DBContext classe Dynamo de cette API fournit des méthodes vous permettant d'enregistrer des objets côté client dans une table, de récupérer des éléments sous forme d'objets et d'effectuer des requêtes et des scans. Vous pouvez utiliser le modèle de persistance des objets pour les opérations de données telles que créer, extraire, mettre à jour et supprimer des éléments. Vous devez d'abord créer vos tables à l'aide de l'API Service Client, puis utiliser le modèle de persistance des objets pour mapper vos classes avec les tables. L'API est disponible dans le fichier Amazon.DynamoDB. DataModel espace de noms.
+ **API Service Client** : il s'agit de l'API au niveau du protocole qui assure un mappage étroit avec l'API DynamoDB. Vous pouvez utiliser cette API de bas niveau pour toutes les opérations de table et d'élément, telles que créer, mettre à jour, supprimer la table et les éléments. Vous pouvez également interroger et analyser vos tables. Cette API est disponible dans le namespace Amazon.DynamoDB.
Ces trois modèles sont abordés de manière approfondie dans les rubriques suivantes :
**Topics**
# Utilisation du modèle de document
Le modèle de document fournit des classes d'enveloppe autour de l'API .NET de bas niveau. Table et Document sont les classes d'enveloppe principales. Vous pouvez utiliser le modèle de document pour créer, récupérer, mettre à jour et supprimer des éléments. Pour créer, mettre à jour et supprimer des tables, vous devez utiliser l'API de bas niveau. Pour obtenir des instructions sur l'utilisation de l'API de bas niveau, consultez la section [Utilisation du niveau de service DynamoDB](dynamodb-integration-lowlevelapi.md). APIs L'API de bas niveau est disponible dans Amazon.DynamoDB. DocumentModel espace de noms.
Pour en savoir plus sur le modèle de document, consultez [Modèle de document .NET](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DotNetSDKMidLevel.html).
## Créer un client DynamoDB
Pour créer un client DynamoDB :
```
var client = new AmazonDynamoDBClient(credentials,region);
DynamoDBContext context = new DynamoDBContext(client);
```
## Opérations CRUD
### Enregistrer un élément
Créer un élément :
```
Table table = Table.LoadTable(client, "Books");
id = Guid.NewGuid().ToString();
var books = new Document();
books["Id"] = id;
books["Author"] = "Mark Twain";
books["Title"] = "Adventures of Huckleberry Finn";
books["ISBN"] = "112-111111";
books["Price"] = "10";
```
Enregistrer un élément dans une table DynamoDB :
```
var book = await table.PutItemAsync(books);
```
### Récupérer un élément
Pour récupérer un élément :
```
public async Task GetItemAsync(AWSCredentials credentials, RegionEndpoint region)
{
var client = new AmazonDynamoDBClient(credentials, region);
Table books = Table.LoadTable(client, "Books");
var book = await books.GetItemAsync(id);
}
```
### Mettre à jour un élément
Pour mettre à jour un élément :
```
public async Task UpdateItemAttributesAsync(AWSCredentials credentials, RegionEndpoint region)
{
var book = new Document();
book["Id"] = id;
book["PageCount"] = "200";
var client = new AmazonDynamoDBClient(credentials, region);
Table books = Table.LoadTable(client, "Books");
Document updatedBook = await books.UpdateItemAsync(book);
}
```
Pour mettre à jour un élément sous certaines conditions :
```
public async Task UpdateItemConditionallyAsync(AWSCredentials credentials, RegionEndpoint region) {
var book = new Document();
book["Id"] = id;
book["Price"] = "30";
// For conditional price update, creating a condition expression.
Expression expr = new Expression();
expr.ExpressionStatement = "Price = :val";
expr.ExpressionAttributeValues[":val"] = 10.00;
var client = new AmazonDynamoDBClient(credentials, region);
Table books = Table.LoadTable(client, "Books");
Document updatedBook = await books.UpdateItemAsync(book);
}
```
### Supprimer un élément
Pour supprimer un élément :
```
public async Task DeleteItemAsync(AWSCredentials credentials, RegionEndpoint region)
{
var client = new AmazonDynamoDBClient(credentials, region);
Table books = Table.LoadTable(client, "Books");
await books.DeleteItemAsync(id);
}
```
### Query and Scan
Pour interroger et récupérer tous les livres dont l'auteur est « Mark Twain » :
```
public async Task QueryAsync(AWSCredentials credentials, RegionEndpoint region) {
var client = new AmazonDynamoDBClient(credentials, region);
Table books = Table.LoadTable(client, "Books");
var search = books.Query(new QueryOperationConfig() {
IndexName = "Author-Title-index",
Filter = new QueryFilter("Author", QueryOperator.Equal, "Mark Twain")
});
Console.WriteLine("ScanAsync: printing query response");
var documents = await search.GetRemainingAsync();
documents.ForEach((d) = > {
PrintDocument(d);
});
}
```
L'exemple de code d'analyse ci-dessous retourne tous les livres de notre table :
```
public async Task ScanAsync(AWSCredentials credentials, RegionEndpoint region) {
var client = new AmazonDynamoDBClient(credentials, region);
Table books = Table.LoadTable(client, "Books");
var search = books.Scan(new ScanOperationConfig() {
ConsistentRead = true
});
Console.WriteLine("ScanAsync: printing scan response");
var documents = await search.GetRemainingAsync();
documents.ForEach((d) = > {
PrintDocument(d);
});
}
```
# Utilisation du modèle de persistance des objets
Le SDK AWS Mobile pour .NET and Xamarin fournit un modèle de persistance des objets qui vous permet de mapper vos classes côté client à une table DynamoDB. Ensuite, chaque instance d'objet est mappée à un élément de la table correspondante. Pour enregistrer vos objets côté client dans une table, le modèle de persistance des objets fournit la DBContext classe Dynamo, un point d'entrée vers DynamoDB. Cette classe permet une connexion à DynamoDB et vous donne la possibilité d'accéder aux tables, d'effectuer diverses opérations CRUD et d'exécuter des requêtes.
Le modèle de persistance des objets n'autorise pas une API à créer, mettre à jour ou supprimer des tables. Il fournit uniquement des opérations sur les données. Pour créer, mettre à jour et supprimer des tables, vous devez utiliser l'API de bas niveau. Pour obtenir des instructions sur l'utilisation de l'API de bas niveau, consultez la section [Utilisation du niveau de service DynamoDB](dynamodb-integration-lowlevelapi.md). APIs
## Présentation de
Le modèle de persistance des objets fournit un ensemble d'attributs permettant de mapper les classes côté client aux tables et properties/fields aux attributs des tables. Le modèle de persistance des objets prend en charge le mappage explicite par défaut entre les propriétés de classe et les attributs de table.
+ **Mappage explicite** : pour associer une propriété à une clé primaire, vous devez utiliser les attributs du modèle Dynamo DBHash Key et Dynamo DBRange Key Object Persistence. En outre, pour les attributs de clé non primaires, si le nom d'une propriété de votre classe et l'attribut de table correspondant auquel vous souhaitez la mapper ne sont pas identiques, vous devez définir le mappage en ajoutant explicitement l'attribut DynamoDBProperty.
+ **Mappage par défaut :**par défaut, le modèle de persistance des objets mappe les propriétés de la classe aux attributs avec le même nom dans la table.
Vous n'avez pas à mapper chaque propriété de classe individuelle. Vous identifiez ces propriétés en ajoutant l'DBIgnore attribut Dynamo. La sauvegarde et la récupération d'une instance d'objet ignorent toutes les propriétés marquées avec cet attribut.
## Types de données pris en charge
Le modèle de persistance des objets prend en charge un ensemble de types de données .NET primitifs, de collections et de types de données arbitraires. Le modèle prend en charge les types de données primitifs suivants.
+ bool
+ octet
+ char
+ DateTime
+ decimal, double, float
+ Int16, Int32, Int64
+ SByte
+ chaîne
+ UInt16, UInt32, UInt64
Le modèle de persistance des objets prend également en charge les types de collection .NET avec les limitations suivantes :
+ Le type de collection doit implémenter ICollection l'interface.
+ Le type de collection doit être composé des types primitifs pris en charge. Par exemple ICollection, ICollection.
+ Le type de collection doit fournir un constructeur sans paramètre.
Pour plus d'informations sur le modèle de persistance des objets, consultez [Modèle de persistance des objets .NET](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DotNetSDKHighLevel.html).
## Créer un client DynamoDB
Pour créer un client DynamoDB :
```
var client = new AmazonDynamoDBClient(credentials,region);
DynamoDBContext context = new DynamoDBContext(client);
```
## Opérations CRUD
### Enregistrer un objet
Créer un objet :
```
[DynamoDBTable("Books")]
public class Book {
[DynamoDBHashKey] // Hash key.
public string Id {
get;
set;
}
[DynamoDBGlobalSecondaryIndexHashKey]
public string Author {
get;
set;
}
[DynamoDBGlobalSecondaryIndexRangeKey]
public string Title {
get;
set;
}
public string ISBN {
get;
set;
}
public int Price {
get;
set;
}
public string PageCount {
get;
set;
}
}
Book myBook = new Book
{
Id = id,
Author = "Charles Dickens",
Title = "Oliver Twist",
ISBN = "111-1111111001",
Price = 10,
PageCount = 300
};
```
Enregistrer un objet dans une table DynamoDB :
```
context.Save(myBook);
```
### Récupérer un objet
Pour récupérer un objet :
```
Book retrievedBook = context.Load(1);
```
### Mettre à jour un objet
Pour mettre à jour un objet :
```
Book retrievedBook = context.Load(1);
retrievedBook.ISBN = "111-1111111001";
context.Save(retrievedBook);
```
### Supprimer un objet
Pour supprimer un objet:
```
Book retrievedBook = context.Load(1);
context.Delete(retrievedBook);
```
## Query and Scan
Pour interroger et récupérer tous les livres dont l'auteur est « Charles Dickens » :
```
public async Task QueryAsync(AWSCredentials credentials, RegionEndpoint region) {
var client = new AmazonDynamoDBClient(credentials, region);
DynamoDBContext context = new DynamoDBContext(client);
var search = context.FromQueryAsync < Book > (new Amazon.DynamoDBv2.DocumentModel.QueryOperationConfig() {
IndexName = "Author-Title-index",
Filter = new Amazon.DynamoDBv2.DocumentModel.QueryFilter("Author", Amazon.DynamoDBv2.DocumentModel.QueryOperator.Equal, "Charles Dickens")
});
Console.WriteLine("items retrieved");
var searchResponse = await search.GetRemainingAsync();
searchResponse.ForEach((s) = > {
Console.WriteLine(s.ToString());
});
}
```
L'exemple de code d'analyse ci-dessous retourne tous les livres de notre table :
```
public async Task ScanAsync(AWSCredentials credentials, RegionEndpoint region) {
var client = new AmazonDynamoDBClient(credentials, region);
DynamoDBContext context = new DynamoDBContext(client);
var search = context.FromScanAsync < Book > (new Amazon.DynamoDBv2.DocumentModel.ScanOperationConfig() {
ConsistentRead = true
});
Console.WriteLine("items retrieved");
var searchResponse = await search.GetRemainingAsync();
searchResponse.ForEach((s) = > {
Console.WriteLine(s.ToString());
});
}
```
# Utilisation du niveau de service DynamoDB APIs
Le niveau de service Dynamo vous APIs permet de créer, de mettre à jour et de supprimer des tables. Vous pouvez également effectuer des opérations de création, lecture, mise à jour et suppression (CRUD) classiques sur des éléments de table à l'aide de cette API.
## Créer un client DynamoDB
Pour créer un client DynamoDB :
```
AmazonDynamoDBClient client = new AmazonDynamoDBClient(credentials,region);
```
## Opérations CRUD
### Enregistrer un élément
Pour enregistrer un élément dans une table DynamoDB :
```
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient(credentials,region);
// Define item attributes
Dictionary attributes = new Dictionary();
// Author is hash-key
attributes["Author"] = new AttributeValue { S = "Mark Twain" };
attributes["Title"] = new AttributeValue { S = "The Adventures of Tom Sawyer" };
attributes["PageCount"] = new AttributeValue { N = "275" };
attributes["Price"] = new AttributeValue{N = "10.00"};
attributes["Id"] = new AttributeValue{N="10"};
attributes["ISBN"] = new AttributeValue{S="111-1111111"};
// Create PutItem request
PutItemRequest request = new PutItemRequest
{
TableName = "Books",
Item = attributes
};
// Issue PutItem request
var response = await client.PutItemAsync(request);
```
### Récupérer un élément
Pour récupérer un élément :
```
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient(credentials,region);
Dictionary key = new Dictionary
{
{ "Id", new AttributeValue { N = "10" } }
};
// Create GetItem request
GetItemRequest request = new GetItemRequest
{
TableName = "Books",
Key = key,
};
// Issue request
var result = await client.GetItemAsync(request);
// View response
Console.WriteLine("Item:");
Dictionary item = result.Item;
foreach (var keyValuePair in item)
{
Console.WriteLine("Author := {0}", item["Author"]);
Console.WriteLine("Title := {0}", item["Title"]);
Console.WriteLine("Price:= {0}", item["Price"]);
Console.WriteLine("PageCount := {0}", item["PageCount"]);
}
```
### Mettre à jour un élément
Pour mettre à jour un élément :
```
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient(credentials,region);
Dictionary key = new Dictionary
{
{ "Id", new AttributeValue { N = "10" } }
};
// Define attribute updates
Dictionary updates = new Dictionary();
// Add a new string to the item's Genres SS attribute
updates["Genres"] = new AttributeValueUpdate()
{
Action = AttributeAction.ADD,
Value = new AttributeValue { SS = new List { "Bildungsroman" } }
};
// Create UpdateItem request
UpdateItemRequest request = new UpdateItemRequest
{
TableName = "Books",
Key = key,
AttributeUpdates = updates
};
// Issue request
var response = await client.UpdateItemAsync(request);
```
### Supprimer un élément
Pour supprimer un élément :
```
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient(credentials,region);
Dictionary key = new Dictionary
{
{ "Id", new AttributeValue { N = "10" } }
};
// Create DeleteItem request
DeleteItemRequest request = new DeleteItemRequest
{
TableName = "Books",
Key = key
};
// Issue request
var response = await client.DeleteItemAsync(request);
```
## Query and Scan
Pour interroger et récupérer tous les livres dont l'auteur est « Mark Twain » :
```
public void Query(AWSCredentials credentials, RegionEndpoint region) {
using(var client = new AmazonDynamoDBClient(credentials, region)) {
var queryResponse = await client.QueryAsync(new QueryRequest() {
TableName = "Books",
IndexName = "Author-Title-index",
KeyConditionExpression = "Author = :v_Id",
ExpressionAttributeValues = new Dictionary < string, AttributeValue > {
{
":v_Id", new AttributeValue {
S = "Mark Twain"
}
}
}
});
queryResponse.Items.ForEach((i) = > {
Console.WriteLine(i["Title"].S);
});
}
}
```
L'exemple de code d'analyse ci-dessous retourne tous les livres de notre table :
```
public void Scan(AWSCredentials credentials, RegionEndpoint region) {
using(var client = new AmazonDynamoDBClient(credentials, region)) {
var queryResponse = client.Scan(new ScanRequest() {
TableName = "Books"
});
queryResponse.Items.ForEach((i) = > {
Console.WriteLine(i["Title"].S);
});
}
}
```