Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Zuordnen beliebiger Daten mit DynamoDB mithilfe des AWS SDK für .NET Objektpersistenzmodells
<a name="DynamoDBContext.ArbitraryDataMapping"></a>

Zusätzlich zu den unterstützten .NET-Typen (siehe [Unterstützte Datentypen](DotNetSDKHighLevel.md#DotNetDynamoDBContext.SupportedTypes)) können Sie Typen in Ihrer Anwendung verwenden, für die es kein direktes Mapping zu Amazon-DynamoDB-Typen gibt. Das Object-Persistence-Modell unterstützt das Speichern von Daten mit beliebigen Typen, solange Sie einen Konverter bereitstellen, um Daten des beliebigen Typs in den DynamoDB-Typ und umgekehrt zu konvertieren. Der Konverter-Code wandelt Daten während des Speicherns und Ladens der Objekte um.

Sie können clientseitig alle Typen erstellen. Die in den Tabellen gespeicherten Daten haben jedoch einen DynamoDB-Datentyp. Während Abfragen und Scans werden alle Datenvergleiche anhand der in DynamoDB gespeicherten Daten ausgeführt.

Das folgende C\$1-Codebeispiel definiert eine `Book`-Klasse mit den Eigenschaften `Id`, `Title`, `ISBN` und `Dimension`. Die Eigenschaft `Dimension` gehört zum `DimensionType`, der die Eigenschaften `Height`, `Width` und `Thickness` beschreibt. Der Beispielcode stellt die Konverter-Methoden `ToEntry` und `FromEntry` bereit, um Daten zwischen den Zeichenfolgetypen `DimensionType` und DynamoDB zu konvertieren. Beispielsweise erstellt der Konverter beim Speichern einer `Book`-Instance eine `Dimension`-Zeichenfolge wie „8.5x11x.05“. Wenn Sie ein Book abrufen, wird die Zeichenfolge in eine `DimensionType`-Instance konvertiert.

Im Beispiel wird der `Book`-Typ der Tabelle `ProductCatalog` zugewiesen. Es speichert eine `Book`-Beispiel-Instance, ruft sie ab, aktualisiert ihre Abmessungen und speichert die aktualisierte `Book`-Instance erneut.



 step-by-stepAnweisungen zum Testen des folgenden Beispiels finden Sie unter. [.NET-Codebeispiele](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;
        }
    }
}
```