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à.

Utilizzo di database Amazon DynamoDB NoSQL

AWS SDK for .NET Supporta Amazon DynamoDB, un servizio di database NoSQL veloce offerto da. AWSL'SDK fornisce tre modelli di programmazione per comunicare con DynamoDB: il modello di basso livello, il modello di documento e il modello di persistenza degli oggetti.

Le seguenti informazioni introducono questi modelli e le relative API, forniscono esempi su come e quando utilizzarli e forniscono collegamenti a risorse di programmazione DynamoDB aggiuntive disponibili in. AWS SDK for .NET

Modello di basso livello

Il modello di programmazione di basso livello include le chiamate dirette al servizio DynamoDB. Puoi accedere a questo modello attraverso lo spazio dei nomi Amazon.DynamoDBv2.

Dei tre modelli, il modello di basso livello richiede di scrivere la maggior parte del codice. Ad esempio, è necessario convertire i tipi di dati.NET nei loro equivalenti in DynamoDB. Tuttavia, questo modello consente di accedere alla maggior parte delle caratteristiche.

Gli esempi seguenti mostrano come utilizzare il modello di basso livello per creare una tabella, modificare una tabella e inserire elementi in una tabella in DynamoDB.

Creazione di una tabella

Nell'esempio seguente, è necessario creare una tabella utilizzando il metodo CreateTable della classe AmazonDynamoDBClient. Il metodo CreateTable utilizza un'istanza della classe CreateTableRequest che contiene caratteristiche quali i nomi degli attributi degli item richiesti, la definizione della chiave primaria e la capacità di throughput. Il metodo CreateTable restituisce un'istanza della classe CreateTableResponse.

// using Amazon.DynamoDBv2;
// using Amazon.DynamoDBv2.Model;

var client = new AmazonDynamoDBClient();

Console.WriteLine("Getting list of tables");
List<string> currentTables = client.ListTables().TableNames;
Console.WriteLine("Number of tables: " + currentTables.Count);
if (!currentTables.Contains("AnimalsInventory"))
{
    var request = new CreateTableRequest
    {
        TableName = "AnimalsInventory",
        AttributeDefinitions = new List<AttributeDefinition>
      {
        new AttributeDefinition
        {
          AttributeName = "Id",
          // "S" = string, "N" = number, and so on.
          AttributeType = "N"
        },
        new AttributeDefinition
        {
          AttributeName = "Type",
          AttributeType = "S"
        }
      },
        KeySchema = new List<KeySchemaElement>
      {
        new KeySchemaElement
        {
          AttributeName = "Id",
          // "HASH" = hash key, "RANGE" = range key.
          KeyType = "HASH"
        },
        new KeySchemaElement
        {
          AttributeName = "Type",
          KeyType = "RANGE"
        },
      },
        ProvisionedThroughput = new ProvisionedThroughput
        {
            ReadCapacityUnits = 10,
            WriteCapacityUnits = 5
        },
    };

    var response = client.CreateTable(request);

    Console.WriteLine("Table created with request ID: " +
      response.ResponseMetadata.RequestId);
}

Verificare che una tabella sia pronta per la modifica

Prima di poterla modificare, una tabella deve essere pronta per la modifica. L'esempio seguente mostra come utilizzare il modello di basso livello per verificare che una tabella in DynamoDB sia pronta. In questo esempio, la tabella di destinazione da verificare viene individuata tramite il metodo DescribeTable della classe AmazonDynamoDBClient. Ogni cinque secondi, il codice verifica il valore della proprietà TableStatus della tabella. Quando lo stato è impostato su ACTIVE, la tabella è pronta per essere modificata.

// using Amazon.DynamoDBv2;
// using Amazon.DynamoDBv2.Model;

var client = new AmazonDynamoDBClient();      
var status = "";

do
{
  // Wait 5 seconds before checking (again).
  System.Threading.Thread.Sleep(TimeSpan.FromSeconds(5));
        
  try
  {
    var response = client.DescribeTable(new DescribeTableRequest
    {
      TableName = "AnimalsInventory"
    });

    Console.WriteLine("Table = {0}, Status = {1}",
      response.Table.TableName,
      response.Table.TableStatus);

    status = response.Table.TableStatus;
  }
  catch (ResourceNotFoundException)
  {
    // DescribeTable is eventually consistent. So you might
    //   get resource not found. 
  }

} while (status != TableStatus.ACTIVE);

Inserimento di un item in una tabella

Nell'esempio seguente, si utilizza il modello di basso livello per inserire due elementi in una tabella in DynamoDB. Ciascun item è inserito tramite il metodo PutItem della classe AmazonDynamoDBClient, utilizzando un'istanza della classe PutItemRequest. Ognuna delle due istanze della classe PutItemRequest richiede il nome della tabella in cui gli item verranno inseriti, con una serie di valori degli attributi degli item.

// using Amazon.DynamoDBv2;
// using Amazon.DynamoDBv2.Model;

var client = new AmazonDynamoDBClient();

var request1 = new PutItemRequest
{
  TableName = "AnimalsInventory",
  Item = new Dictionary<string, AttributeValue>
  {
    { "Id", new AttributeValue { N = "1" }},
    { "Type", new AttributeValue { S = "Dog" }},
    { "Name", new AttributeValue { S = "Fido" }}
  }
};

var request2 = new PutItemRequest
{
  TableName = "AnimalsInventory",
  Item = new Dictionary<string, AttributeValue>
  {
    { "Id", new AttributeValue { N = "2" }},
    { "Type", new AttributeValue { S = "Cat" }},
    { "Name", new AttributeValue { S = "Patches" }}
  }
};
        
client.PutItem(request1);
client.PutItem(request2);

Modello di documento

Il modello di programmazione dei documenti offre un modo più semplice per lavorare con i dati in DynamoDB. Questo modello è progettato in modo specifico per l'accesso alle tabelle e agli item nelle tabelle. È possibile accedere a questo modello tramite amazon.DynamoDBv2. DocumentModelnamespace.

Rispetto al modello di programmazione di basso livello, il modello documentale è più facile da codificare con i dati DynamoDB. Ad esempio, non è necessario convertire tanti tipi di dati.NET nei rispettivi equivalenti in DynamoDB. Tuttavia, questo modello non consente l'accesso a tutte le caratteristiche del modello di programmazione di basso livello. Ad esempio, è possibile usare questo modello per creare, recuperare, aggiornare ed eliminare gli item nelle tabelle. Tuttavia, per creare le tabelle, è necessario utilizzare il modello di basso livello. Rispetto al modello di persistenza dell'oggetto, questo modello richiede la scrittura di codice supplementare per memorizzare, caricare ed eseguire la query degli oggetti .NET.

Per ulteriori informazioni sul modello di programmazione documentale di DynamoDB, consulta.NET: Document model nella Amazon DynamoDB Developer Guide.

Le sezioni seguenti forniscono informazioni su come creare una rappresentazione della tabella DynamoDB desiderata ed esempi su come utilizzare il modello di documento per inserire elementi nelle tabelle e ottenere elementi dalle tabelle.

Creare una rappresentazione della tabella

Per eseguire operazioni sui dati utilizzando il modello di documento, dovete prima creare un'istanza della Table classe che rappresenti una tabella specifica. Esistono due modi principali per eseguire questa operazione.

LoadTable metodo

Il primo meccanismo consiste nell'utilizzare uno dei LoadTable metodi statici della Tableclasse, simile all'esempio seguente:

var client = new AmazonDynamoDBClient();
Table table = Table.LoadTable(client, "Reply");

TableBuilder

Un meccanismo alternativo, la TableBuilderclasse, è stato introdotto nella versione 3.7.203 del pacchetto.DynamoDBv2. AWSSDK NuGet Questo meccanismo può risolvere i comportamenti sopra menzionati rimuovendo alcune chiamate implicite ai metodi, in particolare il metodo. DescribeTable Questo meccanismo viene utilizzato in modo simile all'esempio seguente:

var client = new AmazonDynamoDBClient();
var table = new TableBuilder(client, "Reply")
    .AddHashKey("Id", DynamoDBEntryType.String)
    .AddRangeKey("ReplyDateTime", DynamoDBEntryType.String)
    .AddGlobalSecondaryIndex("PostedBy-Message-index", "Author", DynamoDBEntryType.String, "Message", DynamoDBEntryType.String)
    .Build();

Per ulteriori informazioni su questo meccanismo alternativo, consulta nuovamente il post sul blog Improved DynamoDB Initialization Patterns for the. AWS SDK for .NET

Inserimento di un elemento in una tabella

Nell'esempio seguente, una risposta viene inserita nella tabella Reply tramite il PutItemAsync metodo della Table classe. Il metodo PutItemAsync richiede un'istanza della classe Document; la classe Document è semplicemente una raccolta di attributi inizializzati.

using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DocumentModel;

// Create a representation of the "Reply" table
//  by using one of the mechanisms described previously.

// Then, add a reply to the table.
var newReply = new Document();
newReply["Id"] = Guid.NewGuid().ToString();
newReply["ReplyDateTime"] = DateTime.UtcNow;
newReply["PostedBy"] = "Author1";
newReply["Message"] = "Thank you!";

await table.PutItemAsync(newReply);

Ottenere un elemento da una tabella

Nell'esempio seguente, una risposta viene recuperata tramite il GetItemAsync metodo della Table classe. Per determinare la risposta da ottenere, il GetItemAsync metodo utilizza la chiave hash-and-range primaria della risposta di destinazione.

using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DocumentModel;

// Create a representation of the "Reply" table
//  by using one of the mechanisms described previously.

// Then, get a reply from the table
//  where "guid" is the hash key and "datetime" is the range key.
var reply = await table.GetItemAsync(guid, datetime);
Console.WriteLine("Id = " + reply["Id"]);
Console.WriteLine("ReplyDateTime = " + reply["ReplyDateTime"]);
Console.WriteLine("PostedBy = " + reply["PostedBy"]);
Console.WriteLine("Message = " + reply["Message"]);

L'esempio precedente converte implicitamente i valori della tabella in stringhe per il metodo. WriteLine È possibile eseguire conversioni esplicite utilizzando i vari metodi «As [type]» della classe. DynamoDBEntry Ad esempio, puoi convertire in modo esplicito il valore di Id da un tipo di Primitive dati a un GUID tramite il metodo: AsGuid()

var guid = reply["Id"].AsGuid();

Modello di persistenza degli oggetti

Il modello di programmazione della persistenza degli oggetti è progettato specificamente per l'archiviazione, il caricamento e l'interrogazione di oggetti.NET in DynamoDB. È possibile accedere a questo modello tramite Amazon.DynamoDBV2. DataModelnamespace.

Dei tre modelli, il modello di persistenza degli oggetti è il più semplice da utilizzare come codice ogni volta che si archiviano, caricano o interrogano dati DynamoDB. Ad esempio, lavori direttamente con i tipi di dati DynamoDB. Tuttavia, questo modello fornisce l'accesso solo alle operazioni che archiviano, caricano e interrogano oggetti.NET in DynamoDB. Ad esempio, è possibile usare questo modello per creare, recuperare, aggiornare ed eliminare gli item nelle tabelle. Tuttavia, è necessario prima creare le tabelle utilizzando il modello di basso livello e quindi utilizzare questo modello per mappare le classi .NET alle tabelle.

Per ulteriori informazioni sul modello di programmazione della persistenza degli oggetti DynamoDB, consulta.NET: Object persistence model nella Amazon DynamoDB Developer Guide.

Gli esempi seguenti mostrano come definire una classe.NET che rappresenta un elemento di DynamoDB, utilizzare un'istanza della classe.NET per inserire un elemento in una tabella DynamoDB e utilizzare un'istanza della classe.NET per ottenere un elemento dalla tabella.

Definizione di una classe.NET che rappresenta un elemento in una tabella

Nel seguente esempio di definizione di classe, l'DynamoDBTableattributo specifica il nome della tabella, mentre gli DynamoDBRangeKey attributi DynamoDBHashKey e modellano la chiave hash-and-range primaria della tabella. L'DynamoDBGlobalSecondaryIndexHashKeyattributo è definito in modo da poter creare una query per le risposte di un autore specifico.

using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DataModel;

[DynamoDBTable("Reply")]
public class Reply
{
    [DynamoDBHashKey]
    public string Id { get; set; }

    [DynamoDBRangeKey(StoreAsEpoch = false)]
    public DateTime ReplyDateTime { get; set; }

    [DynamoDBGlobalSecondaryIndexHashKey("PostedBy-Message-Index",
        AttributeName ="PostedBy")]
    public string Author { get; set; }

    [DynamoDBGlobalSecondaryIndexRangeKey("PostedBy-Message-Index")]
    public string Message { get; set; }
}

Creazione di un contesto per il modello di persistenza degli oggetti

Per utilizzare il modello di programmazione della persistenza degli oggetti per DynamoDB, è necessario creare un contesto che fornisca una connessione a DynamoDB e consenta di accedere alle tabelle, eseguire varie operazioni ed eseguire query.

Contesto di base

L'esempio seguente mostra come creare il contesto più semplice.

using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DataModel;

var client = new AmazonDynamoDBClient();
var context = new DynamoDBContext(client);

Contesto con DisableFetchingTableMetadata proprietà

L'esempio seguente mostra come è possibile impostare ulteriormente la DisableFetchingTableMetadata proprietà della DynamoDBContextConfig classe per impedire chiamate implicite al DescribeTable metodo.

using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DataModel;

var client = new AmazonDynamoDBClient();
var context = new DynamoDBContext(client, new DynamoDBContextConfig
{
    DisableFetchingTableMetadata = true
});

Se la DisableFetchingTableMetadata proprietà è impostata su false (impostazione predefinita), come mostrato nel primo esempio, potete omettere dalla classe gli attributi che descrivono la struttura delle chiavi e degli indici degli elementi della tabella. Reply Questi attributi verranno invece dedotti tramite una chiamata implicita al metodo. DescribeTable If DisableFetchingTableMetadata è impostato sutrue, come mostrato nel secondo esempio, sui metodi del modello di persistenza degli oggetti come SaveAsync e QueryAsync si basa interamente sugli attributi definiti nella classe. Reply In questo caso, non viene effettuata una chiamata al DescribeTable metodo.

Utilizzo di un'istanza della classe.NET per inserire un elemento in una tabella

In questo esempio, un elemento viene inserito tramite il SaveAsync metodo della DynamoDBContext classe, che utilizza un'istanza inizializzata della classe.NET che rappresenta l'elemento.

using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DataModel;

// Create an appropriate context for the object persistence programming model,
//  examples of which have been described earlier.

// Create an object that represents the new item.
var reply = new Reply()
{
    Id = Guid.NewGuid().ToString(),
    ReplyDateTime = DateTime.UtcNow,
    Author = "Author1",
    Message = "Thank you!"
};

// Insert the item into the table.
await context.SaveAsync<Reply>(reply, new DynamoDBOperationConfig
{
    IndexName = "PostedBy-Message-index"
});

Utilizzo di un'istanza di una classe.NET per ottenere elementi da una tabella

In questo esempio, viene creata una query per trovare tutti i record di «Author1" utilizzando il QueryAsync metodo della DynamoDBContext classe. Quindi, gli elementi vengono recuperati tramite il metodo della query. GetNextSetAsync

using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DataModel;

// Create an appropriate context for the object persistence programming model,
//  examples of which have been described earlier.

// Construct a query that finds all replies by a specific author.
var query = context.QueryAsync<Reply>("Author1", new DynamoDBOperationConfig
{
    IndexName = "PostedBy-Message-index"
});

// Display the result.
var set = await query.GetNextSetAsync();
foreach (var item in set)
{
    Console.WriteLine("Id = " + item.Id);
    Console.WriteLine("ReplyDateTime = " + item.ReplyDateTime);
    Console.WriteLine("PostedBy = " + item.Author);
    Console.WriteLine("Message = " + item.Message);
}

Informazioni aggiuntive sul modello di persistenza degli oggetti

Gli esempi e le spiegazioni mostrati sopra a volte includono una proprietà della DynamoDBContext classe chiamata. DisableFetchingTableMetadata Questa proprietà, introdotta nella versione 3.7.203 del NuGet pacchetto AWSSDK .DynamoDBv2, consente di evitare determinate condizioni che potrebbero causare latenza o deadlock aggiuntivi dovuti a comportamenti di avvio a freddo e pool di thread. Per ulteriori informazioni, consulta il post sul blog Improved DynamoDB Initialization Patterns for the. AWS SDK for .NET

Di seguito sono riportate alcune informazioni aggiuntive su questa proprietà.

Ulteriori informazioni

Utilizzo di informazioni ed AWS SDK for .NET esempi per programmare DynamoDB**

Informazioni ed esempi sul modello di basso livello

Informazioni ed esempi sul modello di documento

Informazioni ed esempi sul modello di persistenza degli oggetti