ynamoDBContext Classe D del. NETmodello di persistenza degli oggetti

La classe DynamoDBContext è il punto di ingresso al database Amazon DynamoDB. Fornisce una connessione a DynamoDB e consente di accedere ai dati in varie tabelle, eseguire CRUD varie operazioni ed eseguire query. La classe DynamoDBContext fornisce i metodi seguenti:

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.

Eliminazione

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.

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.

Execute​Batch​Write

Scrive o elimina i dati in una o più tabelle, elaborando tutti gli oggetti BatchWrite in un MultiTableBatchWrite.

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 for .NET, vedereLavorare con. NETmodello di documento in DynamoDB.

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 Forumdal Document, come mostrato nell'esempio di codice C# seguente.

forum101 = context.FromDocument<Forum>(101);

FromQuery

Esegue un'operazione Query, con i parametri di query definiti in un oggetto QueryOperationConfig.

FromScan

Esegue un'operazione Scan, con i parametri di scansione definiti in un oggetto ScanOperationConfig.

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.

Loador LoadAsync method chiama l'GetItemoperazione, che richiede di specificare la chiave primaria per la tabella. Poiché GetItem ignora il IndexName parametro, 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.

    /// <summary>
    /// Shows how to perform high-level CRUD operations on an Amazon DynamoDB
    /// table.
    /// </summary>
    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<string> { "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<Book>(bookId);

            // Update some properties.
            bookRetrieved.Isbn = "222-2222221001";

            // Update existing authors list with the following values.
            bookRetrieved.BookAuthors = new List<string> { " 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<Book>(bookId, new DynamoDBContextConfig
            {
                ConsistentRead = true,
            });

            // Delete the book.
            await context.DeleteAsync<Book>(bookId);

            // Try to retrieve deleted book. It should return null.
            Book deletedBook = await context.LoadAsync<Book>(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# seguente esegue una query sulla tabellaReply 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.

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<Reply> latestReplies = context.Query<Reply>(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.

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 for .NET.

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# seguente viene eseguita la scansione della tabella e vengono restituiti solo gli elementi del libro con un prezzo inferiore a 0.

IEnumerable<Book> itemsWithWrongPrice = context.Scan<Book>(
                    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.

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, vedere. AWS SDK for .NETLavorare con. NETmodello di documento in DynamoDB

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# seguente.

DynamoDBContext context = new DynamoDBContext(client);

Forum forum101 = context.Load<Forum>(101); // Retrieve a forum by primary key.
Document doc = context.ToDocument<Forum>(forum101);

Specificazione dei parametri opzionali per D ynamoDBContext

Quando si utilizza il modello di persistenza degli oggetti, è possibile specificare i parametri facoltativi che seguono per DynamoDBContext.

Il seguente esempio in C# ne crea uno nuovo DynamoDBContext specificando due dei parametri opzionali precedenti e. ConsistentRead SkipVersionCheck

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# seguente. L'esempio carica un elemento del libro specifico. Il Load metodo di DynamoDBContext specifica i parametri opzionali. ConsistentRead SkipVersionCheck

AmazonDynamoDBClient client = new AmazonDynamoDBClient();
...
DynamoDBContext context = new DynamoDBContext(client);
Book bookItem = context.Load<Book>(productId,new DynamoDBContextConfig{ ConsistentRead = true, SkipVersionCheck = true });

In questo caso, DynamoDBContext include questi parametri solo quando si invia la richiesta Get.