Mappage de données arbitraires avec DynamoDB à l'aide AWS SDK for .NET du modèle de persistance des objets

En plus du support. NETtypes (voirTypes de données pris en charge), vous pouvez utiliser dans votre application des types pour lesquels il n'existe aucun mappage direct vers les 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# 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, consultez. NETexemples de code.

Exemple

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