Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Operazioni con il modello di persistenza degli oggetti di .NET e DynamoDB AWS SDK per .NET Fornisce un modello di persistenza degli oggetti che consente di mappare le classi lato client alle tabelle Amazon DynamoDB. Ogni istanza dell'oggetto viene quindi mappata a un elemento nelle tabelle corrispondenti. Per salvare gli oggetti lato client nelle tabelle, il modello di persistenza degli oggetti fornisce la classe `DynamoDBContext`, un punto di ingresso a DynamoDB. Questa classe fornisce una connessione a DynamoDB e consente di accedere alle tabelle, eseguire varie operazioni CRUD ed eseguire query. Il modello di persistenza degli oggetti fornisce un set di attributi per mappare le classi lato client alle tabelle e agli attributi delle tabelle. properties/fields **Nota** Il modello di persistenza degli oggetti non fornisce un'API per creare, aggiornare o eliminare tabelle. Esso fornisce solo operazioni di dati. È possibile utilizzare solo l'API di AWS SDK per .NET basso livello per creare, aggiornare ed eliminare tabelle. L'esempio seguente mostra come funziona il modello di persistenza degli oggetti. Inizia con tabella `ProductCatalog`. La tabella dispone di `Id` come chiave primaria. ``` ProductCatalog(Id, ...) ``` Si supponga di avere una classe `Book` con le proprietà `Title`, `ISBN` e `Authors`. È possibile mappare la classe `Book` alla tabella `ProductCatalog`aggiungendo gli attributi definiti dal modello di persistenza degli oggetti, come mostrato nel seguente esempio di codice C\$1. **Example** ``` [DynamoDBTable("ProductCatalog")] public class Book { [DynamoDBHashKey] public int Id { get; set; } public string Title { get; set; } public int ISBN { get; set; } [DynamoDBProperty("Authors")] public List BookAuthors { get; set; } [DynamoDBIgnore] public string CoverPage { get; set; } } ``` Nell'esempio precedente, l'attributo `DynamoDBTable` associa la classe `Book` alla tabella `ProductCatalog`. Il modello di persistenza degli oggetti supporta sia la mappatura esplicita che quella predefinita tra le proprietà della classe e gli attributi della tabella. + **Mappatura esplicita**: per mappare una proprietà a una chiave primaria, è necessario utilizzare gli attributi del modello di persistenza dell'oggetto `DynamoDBHashKey` e `DynamoDBRangeKey`. Inoltre, per gli attributi della chiave non primaria, se il nome di una proprietà nella classe e l'attributo tabella corrispondente a cui si desidera mapparlo non sono gli stessi, è necessario definire la mappatura aggiungendo esplicitamente l'attributo `DynamoDBProperty`. Nell'esempio precedente, la proprietà `Id` viene mappata alla chiave primaria con lo stesso nome e la proprietà `BookAuthors` viene mappata all'attributo `Authors` nella tabella `ProductCatalog`. + **Mappatura predefinita**: per impostazione predefinita, il modello di persistenza degli oggetti mappa le proprietà della classe agli attributi con lo stesso nome nella tabella. Nell'esempio precedente, le proprietà `Title` e `ISBN` vengono mappate agli attributi con lo stesso nome nella tabella `ProductCatalog`. Non è necessario mappare ogni singola proprietà della classe. Queste proprietà vengono identificate aggiungendo l'attributo `DynamoDBIgnore`. Quando si salva un'istanza `Book` nella tabella, `DynamoDBContext` non include la proprietà `CoverPage`. Inoltre, non restituisce questa proprietà quando si recupera l'istanza del libro. È possibile mappare le proprietà di tipi primitivi .NET come int e string. È inoltre possibile mappare qualsiasi tipo di dati arbitrari purché si fornisca un convertitore appropriato per mappare i dati arbitrari a uno dei tipi DynamoDB. Per informazioni sulla mappatura di tipi arbitrari, consulta [Mappatura di dati arbitrari con DynamoDB utilizzando il modello di persistenza degli oggetti AWS SDK per .NET](DynamoDBContext.ArbitraryDataMapping.md). Il modello di persistenza degli oggetti supporta il blocco ottimistico. Durante un'operazione di aggiornamento, questo garantisce di disporre della copia più recente dell'elemento che si sta per aggiornare. Per ulteriori informazioni, consulta [Blocco ottimistico con DynamoDB e il modello di persistenza degli oggetti AWS SDK per .NET](DynamoDBContext.VersionSupport.md). Per ulteriori informazioni, consulta gli argomenti riportati di seguito. **Topics** + [Tipi di dati supportati](#DotNetDynamoDBContext.SupportedTypes) + [Attributi DynamoDB del modello di persistenza degli oggetti di .NET](DeclarativeTagsList.md) + [DBContext Classe Dynamo dal modello di persistenza degli oggetti.NET](DotNetDynamoDBContext.md) + [Blocco ottimistico con DynamoDB e il modello di persistenza degli oggetti AWS SDK per .NET](DynamoDBContext.VersionSupport.md) + [Mappatura di dati arbitrari con DynamoDB utilizzando il modello di persistenza degli oggetti AWS SDK per .NET](DynamoDBContext.ArbitraryDataMapping.md) ## Tipi di dati supportati Il modello di persistenza degli oggetti supporta un insieme di tipi di dati .NET primitivi e tipi di dati arbitrari. Il modello supporta i seguenti tipi di dati primitivi: + `bool` + `byte` + `char` + `DateTime` + `decimal` + `double` + `float` + `Int16` + `Int32` + `Int64` + `SByte` + `string` + `UInt16` + `UInt32` + `UInt64` Il modello di persistenza degli oggetti supporta anche i tipi di raccolte.NET. `DynamoDBContext`è in grado di convertire tipi di raccolta concreti e semplici oggetti Plain Old CLR ()POCOs. Nella tabella seguente viene riepilogata la mappatura dei tipi .NET precedenti ai tipi DynamoDB. **** | Tipo primitivo .NET | Tipo DynamoDB | | --- | --- | | Tutti i tipi di numeri | `N` (tipo numero) | | Tutti i tipi stringa | `S` (tipo stringa) | | MemoryStream, byte [] | `B` (tipo binario) | | bool | N (tipo di numero). 0 rappresenta false e 1 rappresenta true. | | Tipi di raccolta | Tipo BS (set binario), tipo SS (set stringa) o tipo NS (set numerico) | | DateTime | S (tipo stringa). I valori DateTime vengono archiviati come stringhe in formato ISO-8601. | Il modello di persistenza degli oggetti supporta anche tipi di dati arbitrari. Tuttavia, è necessario fornire il codice del convertitore per mappare i tipi complessi ai tipi DynamoDB. **Nota** Sono supportati valori Binary vuoti. È supportata la lettura dei valori String vuoti. I valori degli attributi String vuoti sono supportati all'interno dei valori degli attributi di stringa del tipo Set durante la scrittura su DynamoDB. I valori degli attributi String vuoti del tipo String e i valori String vuoti contenuti nel tipo List o Map vengono eliminati dalle richieste di scrittura # Attributi DynamoDB del modello di persistenza degli oggetti di .NET In questa sezione vengono descritti gli attributi offerti dal modello di persistenza degli oggetti in modo che sia possibile mappare le classi e le proprietà alle tabelle e agli attributi DynamoDB. **Nota** Negli attributi seguenti, solo `DynamoDBTable` e `DynamoDBHashKey` sono obbligatori. ## Dinamo DBGlobal SecondaryIndexHashKey Mappa una proprietà di classe alla chiave di partizione di un indice secondario globale. Utilizza questo attributo se è necessario eseguire una `Query` su un indice secondario globale. ## Dinamo DBGlobal SecondaryIndexRangeKey Associa una proprietà di classe alla chiave di ordinamento di un indice secondario globale. Utilizza questo attributo se è necessario eseguire una `Query` su un indice secondario globale e si desidera rifinire i risultati utilizzando la chiave di ordinamento dell'indice. ## Chiave Dynamo DBHash Mappa una proprietà della classe alla chiave di partizione della chiave primaria della tabella. Gli attributi della chiave primaria non possono essere un tipo di raccolta. L'esempio di codice C\$1 seguente mappa la classe `Book`alla tabella `ProductCatalog` e la proprietà `Id` alla chiave di partizione della chiave primaria della tabella. ``` [DynamoDBTable("ProductCatalog")] public class Book { [DynamoDBHashKey] public int Id { get; set; } // Additional properties go here. } ``` ## Dinamo DBIgnore Indica che la proprietà associata deve essere ignorata. Se non si desidera salvare nessuna delle proprietà di classe, è possibile aggiungere questo attributo per indicare a `DynamoDBContext` di non includere questa proprietà quando si salvano oggetti nella tabella. ## Dinamo DBLocal SecondaryIndexRangeKey Mappa una proprietà di classe alla chiave di ordinamento di un indice secondario globale. Utilizza questo attributo se è necessario eseguire una `Query` su un indice secondario locale e si desidera rifinire i risultati utilizzando la chiave di ordinamento dell'indice. ## Dinamo DBProperty Mappa una proprietà della classe all'attributo di una tabella. Se la proprietà della classe viene mappata a un attributo di tabella con lo stesso nome, non è necessario specificare l'attributo. Tuttavia, se i nomi non sono gli stessi, è possibile utilizzare questo tag per fornire la mappatura. Nella seguente istruzione C\$1, `DynamoDBProperty` mappa la proprietà `BookAuthors` all'attributo `Authors` della tabella. ``` [DynamoDBProperty("Authors")] public List BookAuthors { get; set; } ``` `DynamoDBContext` utilizza queste informazioni di mappatura per creare l'attributo `Authors` quando si salvano i dati dell'oggetto nella tabella corrispondente. ## Dinamo DBRenamable Specifica un nome alternativo per una proprietà di classe. Ciò è utile se si sta scrivendo un convertitore personalizzato per mappare dati arbitrari a una tabella DynamoDB in cui il nome di una proprietà della classe è diverso da un attributo di tabella. ## Chiave Dynamo DBRange Mappa una proprietà di classe alla chiave di ordinamento della chiave primaria della tabella. Se la tabella dispone di una chiave primaria composita (chiave di partizione e chiave di ordinamento), nella mappatura della classe è necessario specificare entrambi gli attributi `DynamoDBHashKey` e `DynamoDBRangeKey`. Ad esempio, la tabella di esempio `Reply` ha una chiave primaria composta dalla chiave di partizione `Id` e dalla chiave di ordinamento `Replenishment`. Nell'esempio di codice C\$1 seguente la classe `Reply` viene mappata alla tabella `Reply`. La definizione di classe indica anche che due delle sue proprietà vengono mappate alla chiave primaria. ``` [DynamoDBTable("Reply")] public class Reply { [DynamoDBHashKey] public int ThreadId { get; set; } [DynamoDBRangeKey] public string Replenishment { get; set; } // Additional properties go here. } ``` ## Dinamo DBTable Identifica la tabella di destinazione di DynamoDB a cui viene mappata la classe. Nell'esempio di codice C\$1 seguente la classe `Developer` viene mappata alla tabella `People` in DynamoDB. ``` [DynamoDBTable("People")] public class Developer { ...} ``` Questo attributo può essere ereditato o sovrascritto. + L'attributo `DynamoDBTable` può essere ereditato. Nell'esempio precedente, se si aggiunge una nuova classe ,`Lead`, che eredita dalla classe `Developer`, la classe viene mappata anche alla tabella `People`. Entrambi gli oggetti `Developer` e `Lead` vengono archiviati nella tabella `People`. + L'attributo `DynamoDBTable` può anche essere sovrascritto. Nel seguente esempio di codice C\$1, la classe `Manager`eredita dalla classe `Developer`. Tuttavia, l'aggiunta esplicita dell'attributo `DynamoDBTable` mappa la classe a un'altra tabella (`Managers`). ``` [DynamoDBTable("Managers")] public class Manager : Developer { ...} ``` È possibile aggiungere il parametro opzionale, `LowerCamelCaseProperties`, per richiedere a DynamoDB di rendere minuscola la prima lettera del nome della proprietà quando si memorizzano gli oggetti in una tabella, come illustrato nell'esempio C\$1 riportato di seguito. ``` [DynamoDBTable("People", LowerCamelCaseProperties=true)] public class Developer { string DeveloperName; ... } ``` Quando si salvano le istanze della classe `Developer`, `DynamoDBContext` salva la proprietà `DeveloperName` come `developerName`. ## Dinamo DBVersion Identifica una proprietà di classe per l'archiviazione del numero di versione dell'elemento. Per ulteriori informazioni sulla funzione Controllo delle versioni, consulta [Blocco ottimistico con DynamoDB e il modello di persistenza degli oggetti AWS SDK per .NET](DynamoDBContext.VersionSupport.md). # DBContext Classe Dynamo dal modello di persistenza degli oggetti.NET La classe `DynamoDBContext` è il punto di ingresso al database Amazon DynamoDB. Fornisce una connessione a DynamoDB e permette di accedere ai dati in varie tabelle, eseguire diverse operazioni CRUD ed eseguire query. La classe `DynamoDBContext` fornisce i metodi seguenti: **Topics** + [Crea MultiTable BatchGet](#w2aac17b9c21c23c39b7) + [Crea MultiTable BatchWrite](#w2aac17b9c21c23c39b9) + [CreateBatchGet](#w2aac17b9c21c23c39c11) + [CreateBatchWrite](#w2aac17b9c21c23c39c13) + [Elimina](#w2aac17b9c21c23c39c15) + [Elimina](#w2aac17b9c21c23c39c17) + [Execute​Batch​Get](#w2aac17b9c21c23c39c19) + [Execute​Batch​Write](#w2aac17b9c21c23c39c21) + [FromDocument](#w2aac17b9c21c23c39c23) + [FromQuery](#w2aac17b9c21c23c39c25) + [FromScan](#w2aac17b9c21c23c39c27) + [Get​Target​Table](#w2aac17b9c21c23c39c29) + [Carica](#w2aac17b9c21c23c39c31) + [Query](#w2aac17b9c21c23c39c33) + [Save (Salva)](#w2aac17b9c21c23c39c35) + [Scan](#w2aac17b9c21c23c39c37) + [ToDocument](#w2aac17b9c21c23c39c39) + [Specificazione dei parametri opzionali per Dynamo DBContext](#OptionalConfigParams) ## Crea MultiTable BatchGet Crea un oggetto `MultiTableBatchGet`, composto da più oggetti `BatchGet`. Ognuno di questi oggetti `BatchGet` può essere utilizzato per recuperare elementi da una singola tabella DynamoDB. Per recuperare gli elementi dalle tabelle, utilizza il metodo `ExecuteBatchGet`, passando l'oggetto `MultiTableBatchGet` come parametro. ## Crea MultiTable BatchWrite Crea un oggetto `MultiTableBatchWrite`, composto da più oggetti `BatchWrite`. Ognuno di questi oggetti `BatchWrite` può essere utilizzato per scrivere o eliminare elementi in una singola tabella DynamoDB. Per scrivere sulle tabelle, utilizza il metodo `ExecuteBatchWrite`, passando l'oggetto `MultiTableBatchWrite` come parametro. ## CreateBatchGet Crea un oggetto `BatchGet` da usare per recuperare più elementi da una tabella. ## CreateBatchWrite Crea un oggetto `BatchWrite` che è possibile utilizzare per inserire più elementi in una tabella o per eliminare più elementi da una tabella. ## Elimina Elimina un item dalla tabella. Il metodo richiede la chiave primaria dell'elemento che si desidera eliminare. È possibile fornire il valore della chiave primaria o un oggetto lato client contenente un valore di chiave primaria come parametro per questo metodo. + Se si specifica un oggetto lato client come parametro ed è stato abilitato il blocco ottimistico, l'eliminazione avrà esito positivo solo se le versioni lato client e lato server dell'oggetto corrispondono. + Se si specifica come parametro solo il valore della chiave primaria, l'eliminazione avrà esito positivo indipendentemente dal fatto che sia stato abilitato o meno il blocco ottimistico. **Nota** Per eseguire questa operazione in background, utilizza invece il metodo `DeleteAsync`. ## Elimina Elimina tutte le risorse gestite e non gestite. ## Execute​Batch​Get Legge i dati da una o più tabelle, elaborando tutti gli oggetti `BatchGet` in un `MultiTableBatchGet`. **Nota** Per eseguire questa operazione in background, utilizza invece il metodo `ExecuteBatchGetAsync`. ## Execute​Batch​Write Scrive o elimina i dati in una o più tabelle, elaborando tutti gli oggetti `BatchWrite` in un `MultiTableBatchWrite`. **Nota** Per eseguire questa operazione in background, utilizza invece il metodo `ExecuteBatchWriteAsync`. ## FromDocument Data un'istanza di un `Document`, il metodo `FromDocument` restituisce un'istanza di una classe lato client. Ciò è utile se si desidera utilizzare le classi del modello di documento insieme al modello di persistenza degli oggetti per eseguire qualsiasi operazione sui dati. Per ulteriori informazioni sulle classi del modello di documento fornite da AWS SDK per .NET, vedere[Utilizzo del modello documentale .NET in DynamoDB](DotNetSDKMidLevel.md). Si supponga di avere un oggetto `Document` denominato `doc`, che contiene una rappresentazione di un elemento `Forum`. Per vedere come costruire questo oggetto, consulta la descrizione del metodo `ToDocument` più avanti in questo argomento). È possibile utilizzare `FromDocument` per recuperare l'elemento `Forum`dal `Document`, come mostrato nell'esempio di codice C\$1 seguente. **Example** ``` forum101 = context.FromDocument(101); ``` **Nota** Se l'oggetto `Document` implementa l'interfaccia `IEnumerable`, è possibile utilizzare invece il metodo `FromDocuments`. Ciò consente di eseguire iterazioni su tutte le istanze della classe nel `Document`. ## FromQuery Esegue un'operazione `Query`, con i parametri di query definiti in un oggetto `QueryOperationConfig`. **Nota** Per eseguire questa operazione in background, utilizza invece il metodo `FromQueryAsync`. ## FromScan Esegue un'operazione `Scan`, con i parametri di scansione definiti in un oggetto `ScanOperationConfig`. **Nota** Per eseguire questa operazione in background, utilizza invece il metodo `FromScanAsync`. ## Get​Target​Table Recupera la tabella di destinazione per il tipo specificato. Ciò è utile se si sta scrivendo un convertitore personalizzato per mappare dati arbitrari a una tabella DynamoDB ed è necessario determinare quale tabella è associata a un tipo di dati personalizzato. ## Carica Recupera un item da una tabella. Il metodo richiede solo la chiave primaria dell'elemento che si desidera recuperare. Per impostazione predefinita, DynamoDB restituisce l'elemento che dispone di valori che sono a consistenza finale. Per informazioni sul modello di consistenza finale, consulta [Coerenza di lettura di DynamoDB](HowItWorks.ReadConsistency.md). `Load`or `LoadAsync` method chiama l'[GetItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_GetItem.html)operazione, che richiede di specificare la chiave primaria per la tabella. Poiché `GetItem` ignora il parametro `IndexName`, non è possibile caricare un elemento utilizzando la partizione o la chiave di ordinamento di un indice. Pertanto, è necessario utilizzare la chiave primaria della tabella per caricare un elemento. **Nota** Per eseguire questa operazione in background, utilizza invece il metodo `LoadAsync`. Per visualizzare un esempio di utilizzo del metodo `LoadAsync` per eseguire operazioni CRUD di alto livello su una tabella DynamoDB, consulta l’esempio seguente. ``` /// /// 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 Interroga una tabella in base ai parametri di query forniti. È possibile eseguire una query su una tabella solo se la tabella dispone di una chiave primaria composita (una chiave di partizione e una chiave di ordinamento). Quando si esegue una query, è necessario specificare una chiave di partizione e una condizione che si applichi alla chiave di ordinamento. Si supponga di disporre di una classe `Reply` lato client mappata alla tabella `Reply` in DynamoDB. L'esempio di codice C\$1 seguente esegue una query sulla tabella`Reply` per ottenere le risposte a un thread del forum pubblicate negli ultimi 15 giorni. La tabella `Reply` ha una chiave primaria che ha la chiave di partizione `Id` e la chiave di ordinamento `ReplyDateTime`. **Example** ``` DynamoDBContext context = new DynamoDBContext(client); string replyId = "DynamoDB#DynamoDB Thread 1"; //Partition key DateTime twoWeeksAgoDate = DateTime.UtcNow.Subtract(new TimeSpan(14, 0, 0, 0)); // Date to compare. IEnumerable latestReplies = context.Query(replyId, QueryOperator.GreaterThan, twoWeeksAgoDate); ``` Restituisce una raccolta di oggetti `Reply`. Il metodo `Query` restituisce una raccolta `IEnumerable` a "caricamento differito". Inizialmente restituisce solo una pagina di risultati e in seguito effettua una chiamata di assistenza per la pagina successiva, se necessario. Per ottenere tutti gli elementi corrispondenti, è necessario iterare solo su `IEnumerable`. Se la tabella ha una chiave primaria semplice (chiave di partizione), non è possibile utilizzare il metodo `Query`. Invece, è possibile utilizzare il metodo `Load` e fornire la chiave di partizione per recuperare l'elemento. **Nota** Per eseguire questa operazione in background, utilizza invece il metodo `QueryAsync`. ## Save (Salva) Salva l'oggetto specificato nella tabella. Se la chiave primaria specificata nell'oggetto di input non esiste nella tabella, il metodo aggiunge un nuovo elemento alla tabella. Se esiste la chiave primaria, il metodo aggiorna l'elemento esistente. Se è stato configurato il blocco ottimistico, l'aggiornamento avrà esito positivo solo se le versioni lato client e lato server dell'elemento corrispondono. Per ulteriori informazioni, consulta [Blocco ottimistico con DynamoDB e il modello di persistenza degli oggetti AWS SDK per .NET](DynamoDBContext.VersionSupport.md). **Nota** Per eseguire questa operazione in background, utilizza invece il metodo `SaveAsync`. ## Scan Esegue la scansione dell'intera tabella. È possibile filtrare i risultati della scansione specificando una condizione di scansione. La condizione può essere valutata in base a qualsiasi attributo nella tabella. Si supponga di disporre di una classe `Book` lato client mappata alla tabella `ProductCatalog` in DynamoDB. Nell'esempio di C\$1 seguente viene eseguita la scansione della tabella e vengono restituiti solo gli elementi del libro con un prezzo inferiore a 0. **Example** ``` IEnumerable itemsWithWrongPrice = context.Scan( new ScanCondition("Price", ScanOperator.LessThan, price), new ScanCondition("ProductCategory", ScanOperator.Equal, "Book") ); ``` Il metodo `Scan` restituisce una raccolta `IEnumerable` a "caricamento differito". Inizialmente restituisce solo una pagina di risultati e in seguito effettua una chiamata di assistenza per la pagina successiva, se necessario. Per ottenere tutti gli elementi corrispondenti, è necessario iterare solo su `IEnumerable`. Per motivi di prestazioni, è preferibile eseguire query sulle tabelle ed evitare le scansioni. **Nota** Per eseguire questa operazione in background, utilizza invece il metodo `ScanAsync`. ## ToDocument Restituisce un'istanza della classe del modello di documento `Document` dall'istanza della classe. Ciò è utile se si desidera utilizzare le classi del modello di documento insieme al modello di persistenza degli oggetti per eseguire qualsiasi operazione sui dati. Per ulteriori informazioni sulle classi del modello di documento fornite da AWS SDK per .NET, vedere[Utilizzo del modello documentale .NET in DynamoDB](DotNetSDKMidLevel.md). Si supponga di disporre di una classe lato client mappata alla tabella `Forum` di esempio. È quindi possibile utilizzare un `DynamoDBContext` per ottenere un elemento come oggetto `Document` dalla tabella `Forum`, come mostrato nell'esempio di codice C\$1 seguente. **Example** ``` DynamoDBContext context = new DynamoDBContext(client); Forum forum101 = context.Load(101); // Retrieve a forum by primary key. Document doc = context.ToDocument(forum101); ``` ## Specificazione dei parametri opzionali per Dynamo DBContext Quando si utilizza il modello di persistenza degli oggetti, è possibile specificare i parametri facoltativi che seguono per `DynamoDBContext`. + **`ConsistentRead`:** quando si recuperano i dati utilizzando le operazioni `Load`, `Query` o `Scan`, è possibile aggiungere questo parametro facoltativo per richiedere i valori più recenti dei dati. + **`IgnoreNullValues`:** questo parametro indica a `DynamoDBContext` di ignorare i valori nulli sugli attributi durante un'operazione `Save`. Se questo parametro è false (o se non è impostato), allora un valore null viene interpretato come una direttiva per eliminare l'attributo specifico. + **`SkipVersionCheck`:** questo parametro indica a `DynamoDBContext` di non confrontare le versioni durante il salvataggio o l'eliminazione di un elemento. Per ulteriori informazioni sulla funzione Controllo delle versioni, consulta [Blocco ottimistico con DynamoDB e il modello di persistenza degli oggetti AWS SDK per .NET](DynamoDBContext.VersionSupport.md). + **`TableNamePrefix`:** aggiunge un prefisso a tutti i nomi delle tabelle con una stringa specifica. Se questo parametro è null (o se non è impostato), allora non viene utilizzato alcun prefisso. + `DynamoDBEntryConversion`: specifica lo schema di conversione utilizzato dal client. È possibile impostare questo parametro sulla versione V1 o V2. V1 è la versione predefinita. In base alla versione impostata, il comportamento di questo parametro cambia. Esempio: + In V1, il tipo di dati `bool` viene convertito nel tipo numerico `N`, dove 0 rappresenta false e 1 rappresenta true. In V2, `bool` viene convertito in `BOOL`. + Nella V2, gli elenchi e gli array non sono raggruppati con. HashSets Gli elenchi e gli array di valori numerici, tipi basati su stringhe e tipi a base binaria vengono convertiti nel tipo `L` (List, elenco), che può essere inviato vuoto per aggiornare un elenco. Il caso è diverso da V1, in cui un elenco vuoto non viene inviata in rete. Nella V1, i tipi di raccolta, come List HashSet, e gli array vengono trattati allo stesso modo. L'elenco e HashSet la matrice di numeri vengono convertiti nel tipo `NS` (set di numeri). L’esempio seguente imposta la versione dello schema di conversione su V2, che modifica il comportamento di conversione tra tipi .NET e tipi di dati DynamoDB. ``` var config = new DynamoDBContextConfig { Conversion = DynamoDBEntryConversion.V2 }; var contextV2 = new DynamoDBContext(client, config); ``` L’esempio C\$1 seguente crea un nuovo `DynamoDBContext` specificando due dei parametri facoltativi precedenti, `ConsistentRead` e `SkipVersionCheck`. **Example** ``` AmazonDynamoDBClient client = new AmazonDynamoDBClient(); ... DynamoDBContext context = new DynamoDBContext(client, new DynamoDBContextConfig { ConsistentRead = true, SkipVersionCheck = true}); ``` `DynamoDBContext` include questi parametri facoltativi con ogni richiesta inviata utilizzando questo contesto. Invece di impostare questi parametri al livello `DynamoDBContext`, è possibile specificarli per le singole operazioni eseguite utilizzando `DynamoDBContext`, come mostrato nell'esempio di codice C\$1 seguente. L'esempio carica un elemento del libro specifico. Il metodo `Load` di `DynamoDBContext` specifica i parametri facoltativi `ConsistentRead` e `SkipVersionCheck`. **Example** ``` AmazonDynamoDBClient client = new AmazonDynamoDBClient(); ... DynamoDBContext context = new DynamoDBContext(client); Book bookItem = context.Load(productId,new DynamoDBContextConfig{ ConsistentRead = true, SkipVersionCheck = true }); ``` In questo caso, `DynamoDBContext` include questi parametri solo quando si invia la richiesta `Get`. # Blocco ottimistico con DynamoDB e il modello di persistenza degli oggetti AWS SDK per .NET Il supporto ottimistico del blocco nel modello di persistenza degli oggetti garantisce che la versione dell'elemento per l'applicazione corrisponda alla versione dell'elemento sul lato server prima di aggiornare o eliminare l'elemento. Si supponga di recuperare un elemento per l'aggiornamento. Tuttavia, prima di inviare nuovamente gli aggiornamenti, alcune altre applicazioni aggiornano lo stesso elemento. In questa situazione, la tua applicazione avrà una copia obsoleta dell'elemento. Senza il blocco ottimistico, qualsiasi aggiornamento eseguito sovrascriverà l'aggiornamento effettuato dall'altra applicazione. La funzione di blocco ottimistica del modello di persistenza degli oggetti fornisce il tag `DynamoDBVersion` che è possibile utilizzare per abilitare il blocco ottimistico. Per utilizzare questa funzionalità, è necessario aggiungere una proprietà alla classe per memorizzare il numero di versione. Quindi aggiungere l'attributo `DynamoDBVersion` alla proprietà. Quando si salva l'oggetto per la prima volta, `DynamoDBContext` assegna un numero di versione che viene incrementato automaticamente ogni volta che si aggiorna l'elemento. Le richieste di aggiornamento ed eliminazione hanno esito positivo solo se la versione dell'oggetto lato client corrisponde al numero di versione dell'elemento corrispondente del lato server. Se l'applicazione dispone di una copia non aggiornata, deve ottenere la versione più recente dal server prima di poter aggiornare o eliminare tale elemento. L'esempio di codice C\$1 seguente definisce una classe `Book` con attributi di persistenza dell'oggetto che la mappano alla tabella `ProductCatalog`. La proprietà `VersionNumber` nella classe lavorata con l'attributo `DynamoDBVersion` memorizza il valore del numero di versione. **Example** ``` [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; } [DynamoDBProperty("Authors")] public List BookAuthors { get; set; } [DynamoDBVersion] public int? VersionNumber { get; set; } } ``` **Nota** Puoi applicare l'attributo `DynamoDBVersion` solo a un tipo primitivo numerico annullabile (come `int?`). Il blocco ottimistico ha il seguente impatto sulle operazioni `DynamoDBContext`: + Per un nuovo elemento, `DynamoDBContext` assegna il numero di versione iniziale uguale a 0. Se si recupera un elemento esistente, si aggiorna una o più delle sue proprietà e si prova a salvare le modifiche, l'operazione di salvataggio ha esito positivo solo se il numero di versione sul lato client e sul lato server corrispondono. `DynamoDBContext` incrementa quindi il numero di versione. Non è necessario impostare il numero di versione. + Il metodo `Delete` fornisce overload che possono assumere il valore di una chiave primaria o un oggetto come parametro, come mostrato nel seguente esempio di codice C\$1. **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); ``` Se si specifica un oggetto come parametro, l'eliminazione ha esito positivo solo se la versione dell'oggetto corrisponde alla versione dell'elemento lato server corrispondente. Tuttavia, se si specifica un valore di chiave primaria come parametro, `DynamoDBContext` non è a conoscenza di alcun numero di versione ed elimina l'elemento senza effettuare il controllo della versione. Tenere presente che l'implementazione interna del blocco ottimistico nel codice del modello di persistenza degli oggetti utilizza l'aggiornamento condizionale e le operazioni API di eliminazione condizionale in DynamoDB. ## Disabilitazione del blocco ottimistico Per disabilitare il blocco ottimistico, utilizza la proprietà di configurazione `SkipVersionCheck`. È possibile impostare questa proprietà durante la creazione di `DynamoDBContext`. In questo caso, il blocco ottimistico è disabilitato per qualsiasi richiesta effettuata utilizzando il contesto. Per ulteriori informazioni, consulta [Specificazione dei parametri opzionali per Dynamo DBContext](DotNetDynamoDBContext.md#OptionalConfigParams). Invece di impostare la proprietà a livello di contesto, è possibile disattivare il blocco ottimistico per un'operazione specifica, come mostrato nel seguente esempio di codice C\$1. Nell'esempio viene utilizzato il contesto per eliminare un elemento del libro. Il metodo `Delete` imposta la proprietà `SkipVersionCheck` facoltativa su true, disabilitando il controllo della versione. **Example** ``` DynamoDBContext context = new DynamoDBContext(client); // Load a book. Book book = context.Load(111); ... // Delete the book. context.Delete(book, new DynamoDBContextConfig { SkipVersionCheck = true }); ``` # Mappatura di dati arbitrari con DynamoDB utilizzando il modello di persistenza degli oggetti AWS SDK per .NET Oltre ai tipi .NET supportati (vedere [Tipi di dati supportati](DotNetSDKHighLevel.md#DotNetDynamoDBContext.SupportedTypes)), è possibile utilizzare i tipi dell'applicazione per i quali non vi è una mappatura diretta ai tipi di Amazon DynamoDB. Il modello di persistenza degli oggetti supporta la memorizzazione di dati di tipi arbitrari purché si fornisca il convertitore per convertire i dati dal tipo arbitrario al tipo DynamoDB e viceversa. Il codice convertitore trasforma i dati sia durante il salvataggio che durante il caricamento degli oggetti. È possibile creare qualsiasi tipo sul lato client. Tuttavia, i dati memorizzati nelle tabelle sono uno dei tipi DynamoDB e durante la query e la scansione, tutti i confronti di dati effettuati sono rispetto ai dati memorizzati in DynamoDB. L'esempio di codice C\$1 seguente definisce una classe `Book` con le proprietà `Id`, `Title`, `ISBN` e `Dimension`. La proprietà `Dimension` è di `DimensionType` che descrive le proprietà `Height`, `Width` e `Thickness`. Il codice di esempio fornisce i metodi del convertitore`ToEntry` e `FromEntry` per convertire i dati tra `DimensionType` e i tipi di stringa DynamoDB. Ad esempio, quando si salva un'istanza `Book`, il convertitore crea una stringa `Dimension` del libro come "8.5x11x.05". Quando recuperi un libro, converte la stringa in un'istanza `DimensionType`. Nell'esempio viene mappato il tipo `Book` alla tabella `ProductCatalog`. Salva un'istanza `Book` di esempio, la recupera, aggiorna le sue dimensioni e salva di nuovo il `Book` aggiornato. Per step-by-step istruzioni su come testare il seguente esempio, consulta. [Esempi di codice .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 { "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; } } } ```