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.

# Mappage de données arbitraires avec DynamoDB à l'aide AWS SDK pour .NET du modèle de persistance des objets
<a name="DynamoDBContext.ArbitraryDataMapping"></a>

En plus des types .NET pris en charge (voir [Types de données pris en charge](DotNetSDKHighLevel.md#DotNetDynamoDBContext.SupportedTypes)), vous pouvez utiliser des types dans votre application pour lesquels il n’y a pas de mappage direct aux types Amazon DynamoDB. Le modèle de persistance des objets prend en charge le stockage de données de types arbitraires tant que vous fournissez le convertisseur pour convertir les données du type arbitraire au type DynamoDB, et inversement. Le code de convertisseur transforme les données lors de l’enregistrement et du chargement des objets.

Vous pouvez créer n’importe quel type côté client. Cependant, les données stockées dans les tables sont l’un des types DynamoDB et, lors de la requête et de l’analyse, toutes les comparaisons de données effectuées sont faites par rapport aux données stockées dans DynamoDB.

L’exemple de code C\$1 suivant définit une classe `Book` avec les propriétés `Id`, `Title`, `ISBN` et `Dimension`. La propriété `Dimension` est du `DimensionType` qui décrit les propriétés `Height`, `Width` et `Thickness`. L’exemple de code fournit les méthodes de convertisseur `ToEntry` et `FromEntry` pour convertir les données entre le `DimensionType` et les types de chaîne DynamoDB. Par exemple, lors de l’enregistrement d’une instance `Book`, le convertisseur crée une chaîne de `Dimension` de livre telle que « 8.5x11x.05 ». Lorsque vous récupérez un livre, il convertit la chaîne en instance `DimensionType`.

L’exemple mappe le type `Book` à la table `ProductCatalog`. Il enregistre un exemple d’instance `Book`, le récupère, met à jour ses dimensions et enregistre de nouveau le `Book` mis à jour.



Pour step-by-step obtenir des instructions sur le test de l'exemple suivant, reportez-vous à[Exemples de code .NET](CodeSamples.DotNet.md).

**Example**  

```
using System;
using System.Collections.Generic;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DataModel;
using Amazon.DynamoDBv2.DocumentModel;
using Amazon.Runtime;
using Amazon.SecurityToken;

namespace com.amazonaws.codesamples
{
    class HighLevelMappingArbitraryData
    {
        private static AmazonDynamoDBClient client = new AmazonDynamoDBClient();

        static void Main(string[] args)
        {
            try
            {
                DynamoDBContext context = new DynamoDBContext(client);

                // 1. Create a book.
                DimensionType myBookDimensions = new DimensionType()
                {
                    Length = 8M,
                    Height = 11M,
                    Thickness = 0.5M
                };

                Book myBook = new Book
                {
                    Id = 501,
                    Title = "AWS SDK for .NET Object Persistence Model Handling Arbitrary Data",
                    ISBN = "999-9999999999",
                    BookAuthors = new List<string> { "Author 1", "Author 2" },
                    Dimensions = myBookDimensions
                };

                context.Save(myBook);

                // 2. Retrieve the book.
                Book bookRetrieved = context.Load<Book>(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<string> 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;
        }
    }
}
```