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.
# Interfaces de programmation de niveau supérieur pour DynamoDB
bookAuthors;
private String someProp;
@DynamoDBHashKey(attributeName="Id")
public Integer getId() { return id; }
public void setId(Integer id) {this.id = id; }
@DynamoDBAttribute(attributeName="Title")
public String getTitle() {return title; }
public void setTitle(String title) { this.title = title; }
@DynamoDBAttribute(attributeName="ISBN")
public String getISBN() { return ISBN; }
public void setISBN(String ISBN) { this.ISBN = ISBN; }
@DynamoDBAttribute(attributeName="Authors")
public Set getBookAuthors() { return bookAuthors; }
public void setBookAuthors(Set bookAuthors) { this.bookAuthors = bookAuthors; }
@DynamoDBIgnore
public String getSomeProp() { return someProp; }
public void setSomeProp(String someProp) { this.someProp = someProp; }
}
```
Dans le code précédent, l’annotation `@DynamoDBTable` mappe la classe `CatalogItem` à la table `ProductCatalog`. Vous pouvez stocker des instances de classe individuelles en tant qu’éléments dans la table. Dans la définition de classe, l’annotation `@DynamoDBHashKey` mappe l’`Id` de propriété à la clé primaire.
Par défaut, les propriétés de classe mappent avec les mêmes attributs de nom dans la table. Les propriétés `Title` et `ISBN` mappent avec les mêmes attributs de nom dans la table.
L’annotation `@DynamoDBAttribute` est facultative si le nom de l’attribut DynamoDB correspond au nom de la propriété déclarée dans la classe. Si les noms diffèrent, utilisez cette annotation avec le paramètre `attributeName` pour spécifier l’attribut DynamoDB auquel cette propriété correspond.
Dans l’exemple précédent, l’annotation `@DynamoDBAttribute` est ajoutée à chaque propriété afin de garantir que les noms de propriété correspondent exactement aux tables créées au cours d’une étape précédente et d’assurer la cohérence avec les noms d’attributs utilisés dans d’autres exemples de code dans ce guide.
Votre définition de classe peut avoir des propriétés qui ne mappent avec aucun attribut de la table. Vous identifiez ces propriétés en ajoutant l’annotation `@DynamoDBIgnore`. Dans l’exemple précédent, la propriété `SomeProp` est marquée avec l’annotation `@DynamoDBIgnore`. Lorsque vous téléchargez une instance `CatalogItem` vers la table, votre instance `DynamoDBMapper` n’inclut pas de propriété `SomeProp`. En outre, l’outil de mappage ne retourne pas cet attribut lorsque vous récupérez un élément de la table.
Une fois que vous avez défini votre classe de mappage, vous pouvez utiliser des méthodes `DynamoDBMapper` pour écrire une instance de cette classe d’un élément correspondant dans la table `Catalog`. L’exemple de code suivant illustre cette technique.
```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDBMapper mapper = new DynamoDBMapper(client);
CatalogItem item = new CatalogItem();
item.setId(102);
item.setTitle("Book 102 Title");
item.setISBN("222-2222222222");
item.setBookAuthors(new HashSet(Arrays.asList("Author 1", "Author 2")));
item.setSomeProp("Test");
mapper.save(item);
```
L’exemple de code suivant montre comment récupérer l’élément et accéder à certains de ses attributs :
```
CatalogItem partitionKey = new CatalogItem();
partitionKey.setId(102);
DynamoDBQueryExpression queryExpression = new DynamoDBQueryExpression()
.withHashKeyValues(partitionKey);
List itemList = mapper.query(CatalogItem.class, queryExpression);
for (int i = 0; i < itemList.size(); i++) {
System.out.println(itemList.get(i).getTitle());
System.out.println(itemList.get(i).getBookAuthors());
}
```
`DynamoDBMapper` offre un moyen intuitif, naturel d’utiliser des données DynamoDB dans Java. Il offre aussi différentes fonctionnalités intégrées telles que le verrouillage optimiste, les transactions ACID, les valeurs de clé de tri et de clé de partition générées automatiquement et la gestion des versions d’objet.
# Classe Dynamo DBMapper
eav = new HashMap();
eav.put(":v1", new AttributeValue().withS(partitionKey));
eav.put(":v2",new AttributeValue().withS(twoWeeksAgoStr.toString()));
DynamoDBQueryExpression queryExpression = new DynamoDBQueryExpression()
.withKeyConditionExpression("Id = :v1 and ReplyDateTime > :v2")
.withExpressionAttributeValues(eav);
List latestReplies = mapper.query(Reply.class, queryExpression);
```
La requête renvoie un ensemble d’objets `Reply`.
Par défaut, la méthode `query` renvoie une collection « avec chargement différé ». Elle ne renvoie initialement qu’une seule page de résultats puis effectue un appel de service pour la page suivante si nécessaire. Pour obtenir tous les éléments correspondants, itérez sur la collection `latestReplies`.
Notez que l’appel de la méthode `size()` sur la collection chargera chaque résultat afin de fournir un décompte précis. Cela peut entraîner la consommation d’un débit alloué élevé et, sur une très grande table, pourrait même épuiser toute la mémoire de votre JVM.
Pour interroger un index, vous devez tout d’abord affecter un modèle à l’index en tant que classe d’outil de mappage. Supposons que la `Reply` table possède un index secondaire global nommé *PostedBy-Message-Index*. La clé de partition de cet index est `PostedBy`, et la clé de tri est `Message`. La définition de classe d’un élément dans l’index se présenterait comme suit :
```
@DynamoDBTable(tableName="Reply")
public class PostedByMessage {
private String postedBy;
private String message;
@DynamoDBIndexHashKey(globalSecondaryIndexName = "PostedBy-Message-Index", attributeName = "PostedBy")
public String getPostedBy() { return postedBy; }
public void setPostedBy(String postedBy) { this.postedBy = postedBy; }
@DynamoDBIndexRangeKey(globalSecondaryIndexName = "PostedBy-Message-Index", attributeName = "Message")
public String getMessage() { return message; }
public void setMessage(String message) { this.message = message; }
// Additional properties go here.
}
```
L’annotation `@DynamoDBTable` indique que cet index est associé à la table `Reply`. L'`@DynamoDBIndexHashKey`annotation indique la clé de partition (*PostedBy*) de l'index et `@DynamoDBIndexRangeKey` la clé de tri (*Message*) de l'index.
Vous pouvez maintenant utiliser `DynamoDBMapper` pour interroger l’index, en récupérant un sous-ensemble de messages qui ont été publiés par un utilisateur particulier. Il n’est pas nécessaire de spécifier le nom de l’index si vous n’avez pas de mappages contradictoires entre les tables et les index et si les mappages sont déjà établis dans l’outil de mappage. L’outil de mappage déduit en fonction de la clé primaire et de la clé de tri. L’exemple de code suivant interroge un index secondaire global. Étant donné que les index globaux secondaires (gsi) prennent en charge des lectures cohérentes à terme, mais pas des lectures fortement cohérentes, vous devez spécifier `withConsistentRead(false)`.
```
HashMap eav = new HashMap();
eav.put(":v1", new AttributeValue().withS("User A"));
eav.put(":v2", new AttributeValue().withS("DynamoDB"));
DynamoDBQueryExpression queryExpression = new DynamoDBQueryExpression()
.withIndexName("PostedBy-Message-Index")
.withConsistentRead(false)
.withKeyConditionExpression("PostedBy = :v1 and begins_with(Message, :v2)")
.withExpressionAttributeValues(eav);
List iList = mapper.query(PostedByMessage.class, queryExpression);
```
La requête renvoie un ensemble d’objets `PostedByMessage`.
## queryPage
eav = new HashMap();
eav.put(":v1", new AttributeValue().withS("2015"));
DynamoDBScanExpression scanExpression = new DynamoDBScanExpression()
.withFilterExpression("begins_with(ReplyDateTime,:v1)")
.withExpressionAttributeValues(eav);
List replies = mapper.scan(Reply.class, scanExpression);
```
Par défaut, la méthode `scan` renvoie une collection « avec chargement différé ». Elle ne renvoie initialement qu’une seule page de résultats puis effectue un appel de service pour la page suivante si nécessaire. Pour obtenir tous les éléments correspondants, itérez sur la collection `replies`.
Notez que l’appel de la méthode `size()` sur la collection chargera chaque résultat afin de fournir un décompte précis. Cela peut entraîner la consommation d’un débit alloué élevé et, sur une très grande table, pourrait même épuiser toute la mémoire de votre JVM.
Pour analyser un index, vous devez tout d’abord affecter un modèle à l’index en tant que classe d’outil de mappage. Supposons que la table `Reply` a un index secondaire global nommé `PostedBy-Message-Index`. La clé de partition de cet index est `PostedBy`, et la clé de tri est `Message`. Une classe d’outil de mappage pour cet index est disponible dans la section [query](#DynamoDBMapper.Methods.query). Elle utilise les annotations `@DynamoDBIndexHashKey` et `@DynamoDBIndexRangeKey` pour spécifier la clé de partition et la clé de tri de l’index.
L’exemple de code suivant présente analyse `PostedBy-Message-Index`. Il n’utilise pas un filtre d’analyse. Ainsi, tous les éléments dans l’index vous sont renvoyés.
```
DynamoDBScanExpression scanExpression = new DynamoDBScanExpression()
.withIndexName("PostedBy-Message-Index")
.withConsistentRead(false);
List iList = mapper.scan(PostedByMessage.class, scanExpression);
Iterator indexItems = iList.iterator();
```
## scanPage
eav = new HashMap();
eav.put(":n", new AttributeValue().withN("100"));
DynamoDBScanExpression scanExpression = new DynamoDBScanExpression()
.withFilterExpression("Price <= :n")
.withExpressionAttributeValues(eav);
List scanResult = mapper.parallelScan(Product.class, scanExpression, numberOfThreads);
```
## batchSave
itemsToGet = new ArrayList();
ForumItem forumItem = new ForumItem();
forumItem.setForumName("Amazon DynamoDB");
itemsToGet.add(forumItem);
ThreadItem threadItem = new ThreadItem();
threadItem.setForumName("Amazon DynamoDB");
threadItem.setSubject("Amazon DynamoDB thread 1 message text");
itemsToGet.add(threadItem);
Map> items = mapper.batchLoad(itemsToGet);
```
## batchDelete
objectsToWrite = Arrays.asList(forumItem, threadItem);
List objectsToDelete = Arrays.asList(book3);
mapper.batchWrite(objectsToWrite, objectsToDelete);
```
## transactionWrite
getBookAuthors() { return BookAuthors; }
public void setBookAuthors(List BookAuthors) { this.BookAuthors = BookAuthors; }
```
Le `DynamoDBMapper` utilise `Authors` en tant que nom d’attribut lors de l’enregistrement de l’objet vers la table.
## Dynamo DBAuto GeneratedKey
bookAuthors;
private String someProp;
private Long version;
@DynamoDBHashKey(attributeName="Id")
public Integer getId() { return id; }
public void setId(Integer Id) { this.id = Id; }
@DynamoDBAttribute(attributeName="Title")
public String getTitle() { return title; }
public void setTitle(String title) { this.title = title; }
@DynamoDBAttribute(attributeName="ISBN")
public String getISBN() { return ISBN; }
public void setISBN(String ISBN) { this.ISBN = ISBN;}
@DynamoDBAttribute(attributeName = "Authors")
public Set getBookAuthors() { return bookAuthors; }
public void setBookAuthors(Set bookAuthors) { this.bookAuthors = bookAuthors; }
@DynamoDBIgnore
public String getSomeProp() { return someProp;}
public void setSomeProp(String someProp) {this.someProp = someProp;}
@DynamoDBVersionAttribute
public Long getVersion() { return version; }
public void setVersion(Long version) { this.version = version;}
}
```
Vous pouvez appliquer l’annotation `@DynamoDBVersionAttribute` aux types Nullable proposés par les classes de wrappers primitifs qui fournissent un type Nullable, par exemple `Long` et `Integer`.
Le verrouillage optimiste a l’impact suivant sur ces méthodes `DynamoDBMapper` :
+ `save` – Pour un nouvel élément, le `DynamoDBMapper` attribue un numéro de version initial 1. Si vous récupérez un élément, que vous mettez à jour une ou plusieurs de ses propriétés et que vous tentez d’enregistrer les modifications, l’opération de sauvegarde n’aboutit que si les numéros de version côté client et côté serveur correspondent. Le `DynamoDBMapper` augmente le numéro de version automatiquement.
+ `delete` – La méthode `delete` prend un objet en tant que paramètre, et le `DynamoDBMapper` effectue une vérification de version avant de supprimer l’élément. Le contrôle de version peut être désactivé si `DynamoDBMapperConfig.SaveBehavior.CLOBBER` est spécifié dans la demande.
L’implémentation interne de verrouillage optimiste au sein de `DynamoDBMapper` utilise la prise en charge de suppression et de mise à jour conditionnelles fournies par DynamoDB.
+ `transactionWrite` —
+ `Put` – Pour un nouvel élément, le `DynamoDBMapper` attribue un numéro de version initial 1. Si vous récupérez un élément, que vous mettez à jour une ou plusieurs de ses propriétés et que vous tentez d’enregistrer les modifications, l’opération « Put » n’aboutit que si les numéros de version côté client et côté serveur correspondent. Le `DynamoDBMapper` augmente le numéro de version automatiquement.
+ `Update` – Pour un nouvel élément, le `DynamoDBMapper` attribue un numéro de version initial 1. Si vous récupérez un élément, que vous mettez à jour une ou plusieurs de ses propriétés et que vous tentez d’enregistrer les modifications, l’opération de mise à jour n’aboutit que si les numéros de version côté client et côté serveur correspondent. Le `DynamoDBMapper` augmente le numéro de version automatiquement.
+ `Delete` – Le `DynamoDBMapper` effectue une vérification de version avant de supprimer l’élément. L’opération de suppression n’aboutit que si les numéros de version côté client et côté serveur correspondent.
+ `ConditionCheck` – L’annotation `@DynamoDBVersionAttribute` n’est pas prise en charge pour les opérations `ConditionCheck`. Un SdkClientException sera lancé lorsqu'un `ConditionCheck` élément est annoté avec`@DynamoDBVersionAttribute`.
## Désactivation du verrouillage optimiste
(Arrays.asList("Author1", "Author2")));
book.setDimensions(dimType);
DynamoDBMapper mapper = new DynamoDBMapper(client);
mapper.save(book);
Book bookRetrieved = mapper.load(Book.class, 502);
System.out.println("Book info: " + "\n" + bookRetrieved);
bookRetrieved.getDimensions().setHeight("9.0");
bookRetrieved.getDimensions().setLength("12.0");
bookRetrieved.getDimensions().setThickness("2.0");
mapper.save(bookRetrieved);
bookRetrieved = mapper.load(Book.class, 502);
System.out.println("Updated book info: " + "\n" + bookRetrieved);
}
@DynamoDBTable(tableName = "ProductCatalog")
public static class Book {
private int id;
private String title;
private String ISBN;
private Set bookAuthors;
private DimensionType dimensionType;
// Partition key
@DynamoDBHashKey(attributeName = "Id")
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@DynamoDBAttribute(attributeName = "Title")
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
@DynamoDBAttribute(attributeName = "ISBN")
public String getISBN() {
return ISBN;
}
public void setISBN(String ISBN) {
this.ISBN = ISBN;
}
@DynamoDBAttribute(attributeName = "Authors")
public Set getBookAuthors() {
return bookAuthors;
}
public void setBookAuthors(Set bookAuthors) {
this.bookAuthors = bookAuthors;
}
@DynamoDBTypeConverted(converter = DimensionTypeConverter.class)
@DynamoDBAttribute(attributeName = "Dimensions")
public DimensionType getDimensions() {
return dimensionType;
}
@DynamoDBAttribute(attributeName = "Dimensions")
public void setDimensions(DimensionType dimensionType) {
this.dimensionType = dimensionType;
}
@Override
public String toString() {
return "Book [ISBN=" + ISBN + ", bookAuthors=" + bookAuthors + ", dimensionType= "
+ dimensionType.getHeight() + " X " + dimensionType.getLength() + " X "
+ dimensionType.getThickness()
+ ", Id=" + id + ", Title=" + title + "]";
}
}
static public class DimensionType {
private String length;
private String height;
private String thickness;
public String getLength() {
return length;
}
public void setLength(String length) {
this.length = length;
}
public String getHeight() {
return height;
}
public void setHeight(String height) {
this.height = height;
}
public String getThickness() {
return thickness;
}
public void setThickness(String thickness) {
this.thickness = thickness;
}
}
// Converts the complex type DimensionType to a string and vice-versa.
static public class DimensionTypeConverter implements DynamoDBTypeConverter {
@Override
public String convert(DimensionType object) {
DimensionType itemDimensions = (DimensionType) object;
String dimension = null;
try {
if (itemDimensions != null) {
dimension = String.format("%s x %s x %s", itemDimensions.getLength(), itemDimensions.getHeight(),
itemDimensions.getThickness());
}
} catch (Exception e) {
e.printStackTrace();
}
return dimension;
}
@Override
public DimensionType unconvert(String s) {
DimensionType itemDimension = new DimensionType();
try {
if (s != null && s.length() != 0) {
String[] data = s.split("x");
itemDimension.setLength(data[0].trim());
itemDimension.setHeight(data[1].trim());
itemDimension.setThickness(data[2].trim());
}
} catch (Exception e) {
e.printStackTrace();
}
return itemDimension;
}
}
}
```
# Exemples DynamoDBMapper
BookAuthors { get; set; }
[DynamoDBIgnore]
public string CoverPage { get; set; }
}
```
Dans l’exemple précédent, l’attribut `DynamoDBTable` mappe la classe `Book` à la table `ProductCatalog`.
Le modèle de persistance des objets prend en charge les mappages explicite et par défaut entre les propriétés de classe et les attributs de table.
+ **Mappage explicite – **Pour mapper une propriété à une clé primaire, vous devez utiliser les attributs de modèle de persistance des objets `DynamoDBHashKey` et `DynamoDBRangeKey`. En outre, pour les attributs de clé non primaire, si un nom de propriété de votre classe et l’attribut de table correspondant auquel vous voulez le mapper ne sont pas identiques, vous devez définir le mappage en ajoutant explicitement l’attribut `DynamoDBProperty`.
Dans l’exemple précédent, la propriété `Id` mappe à la clé primaire du même nom, et la propriété `BookAuthors` mappe à l’attribut `Authors` dans la table `ProductCatalog`.
+ **Mappage par défaut – **Par défaut, le modèle de persistance des objets mappe les propriétés de classe aux attributs du même nom dans la table.
Dans l’exemple précédent, les propriétés `Title` et `ISBN` mappent aux attributs du même nom dans la table `ProductCatalog`.
Vous n’avez pas à mapper chaque propriété de classe. Vous identifiez ces propriétés en ajoutant l’attribut `DynamoDBIgnore`. Lorsque vous enregistrez une instance `Book` dans la table, le `DynamoDBContext` n’inclut pas la propriété `CoverPage`. Il ne renvoie pas non plus cette propriété lorsque vous récupérez l’instance livre.
Vous pouvez mapper des propriétés de types primitifs .NET tels que int et string. Vous pouvez également mapper n’importe quels types de données arbitraires tant que vous fournissez un convertisseur approprié pour mapper les données arbitraires à l’un des types DynamoDB. Pour en savoir plus sur le mappage de types arbitraires, consultez [Mappage de données arbitraires avec DynamoDB à l'aide AWS SDK pour .NET du modèle de persistance des objets](DynamoDBContext.ArbitraryDataMapping.md).
Le modèle de persistance des objets prend en charge le verrouillage optimiste. Au cours d’une opération de mise à jour, cela garantit que vous disposez de la dernière copie de l’élément que vous êtes sur le point de mettre à jour. Pour de plus amples informations, veuillez consulter [Verrouillage optimiste à l'aide de DynamoDB et du modèle de persistance des objets AWS SDK pour .NET](DynamoDBContext.VersionSupport.md).
Pour plus d’informations, consultez les rubriques ci-dessous.
**Topics**
+ [Types de données pris en charge](#DotNetDynamoDBContext.SupportedTypes)
+ [Attributs DynamoDB du modèle de persistance des objets .NET](DeclarativeTagsList.md)
+ [DBContext Classe Dynamo issue du modèle de persistance des objets .NET](DotNetDynamoDBContext.md)
+ [Verrouillage optimiste à l'aide de DynamoDB et du modèle de persistance des objets AWS SDK pour .NET](DynamoDBContext.VersionSupport.md)
+ [Mappage de données arbitraires avec DynamoDB à l'aide AWS SDK pour .NET du modèle de persistance des objets](DynamoDBContext.ArbitraryDataMapping.md)
## Types de données pris en charge
BookAuthors { get; set; }
```
`DynamoDBContext` utilise ces informations de mappage pour créer l’attribut `Authors` lors de l’enregistrement de données d’objet dans la table correspondante.
## Dynamo DBRenamable
(101);
```
**Note**
Si votre objet `Document` implémente l’interface `IEnumerable`, vous pouvez utiliser la méthode `FromDocuments` à la place. Cela vous permet d'itérer sur toutes les instances de classe dans le `Document`.
## FromQuery
/// 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
latestReplies = context.Query(replyId, QueryOperator.GreaterThan, twoWeeksAgoDate);
```
Ceci renvoie une collection d’objets `Reply`.
La méthode `Query` renvoie une collection `IEnumerable` « avec chargement différé ». Elle ne renvoie initialement qu’une seule page de résultats puis effectue un appel de service pour la page suivante si nécessaire. Pour obtenir tous les éléments correspondants, vous devez itérer uniquement sur la collection `IEnumerable`.
Si votre table possède une clé primaire simple (clé de partition), vous ne pouvez pas utiliser la méthode `Query`. Au lieu de cela, vous pouvez utiliser la méthode `Load` et fournir la clé de partition pour récupérer l’élément.
**Note**
Pour effectuer cette opération en arrière-plan, utilisez la méthode `QueryAsync` à la place.
## Enregistrer
itemsWithWrongPrice = context.Scan(
new ScanCondition("Price", ScanOperator.LessThan, price),
new ScanCondition("ProductCategory", ScanOperator.Equal, "Book")
);
```
La méthode `Scan` renvoie une collection `IEnumerable` « avec chargement différé ». Elle ne renvoie initialement qu’une seule page de résultats puis effectue un appel de service pour la page suivante si nécessaire. Pour obtenir tous les éléments correspondants, vous devez seulement itérer sur la collection `IEnumerable`.
Pour des raisons de performance, vous devez interroger vos tables et éviter une analyse de table.
**Note**
Pour effectuer cette opération en arrière-plan, utilisez la méthode `ScanAsync` à la place.
## ToDocument
(101); // Retrieve a forum by primary key.
Document doc = context.ToDocument(forum101);
```
## Spécification de paramètres facultatifs pour Dynamo DBContext
(productId,new DynamoDBContextConfig{ ConsistentRead = true, SkipVersionCheck = true });
```
Dans ce cas, `DynamoDBContext` inclut ces paramètres uniquement lors de l’envoi de la demande `Get`.
# Verrouillage optimiste à l'aide de DynamoDB et du modèle de persistance des objets AWS SDK pour .NET
BookAuthors { get; set; }
[DynamoDBVersion]
public int? VersionNumber { get; set; }
}
```
**Note**
Vous pouvez appliquer l’attribut `DynamoDBVersion` uniquement à un type primitif numérique nullable (tel que `int?`).
Le verrouillage optimiste a l’impact suivant sur les opérations `DynamoDBContext` :
+ Pour un nouvel élément, `DynamoDBContext` attribue le numéro de version initial 0. Si vous récupérez un élément existant, mettez à jour une ou plusieurs de ses propriétés, puis tentez d’enregistrer les modifications, l’opération d’enregistrement n’aboutit que si les numéros de version côté client et côté serveur correspondent. `DynamoDBContext` incrémente le numéro de version. Vous n’avez pas besoin de définir le numéro de version.
+ La méthode `Delete` fournit des surcharges pouvant prendre une valeur de clé primaire ou un objet en tant que paramètre, comme illustré dans l’exemple de code C\$1 suivant.
**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);
```
Si vous fournissez un objet en tant que paramètre, la suppression ne réussit que si la version de l’objet correspond à la version de l’élément côté serveur. Toutefois, si vous fournissez une valeur de clé primaire en tant que paramètre, `DynamoDBContext` ne connaît aucun numéro de version, et supprime l’élément sans effectuer la vérification de version.
Notez que l’implémentation interne du verrouillage optimiste dans le code du modèle de persistance des objets utilise les actions d’API de mise à jour conditionnelle et de suppression conditionnelle dans DynamoDB.
## Désactivation du verrouillage optimiste
(111);
...
// Delete the book.
context.Delete(book, new DynamoDBContextConfig { SkipVersionCheck = true });
```
# Mappage de données arbitraires avec DynamoDB à l'aide AWS SDK pour .NET du modèle de persistance des objets
{ "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;
}
}
}
```