Collocazione di un elemento Ottenimento di un elemento Aggiornamento di un elemento Contatore atomico Eliminazione di un elemento Scrittura in batch: collocazione ed eliminazione di più elementi Ricezione in batch: ricezione di più elementi

Lavorare con gli oggetti:. NET

È possibile utilizzare il AWS SDK for .NET livello basso API per eseguire le tipiche operazioni di creazione, lettura, aggiornamento ed eliminazione (CRUD) su un elemento di una tabella. Di seguito sono riportati i passaggi comuni da seguire per eseguire CRUD operazioni sui dati utilizzando. NETdi basso livelloAPI:

Crea un'istanza della classe AmazonDynamoDBClient (client).
Fornisci i parametri obbligatori e specifici per l'operazione in un oggetto di richiesta corrispondente.

Per esempio, usa l'oggetto di richiesta PutItemRequest durante il caricamento di un item e l'oggetto di richiesta GetItemRequest quando recuperi un item esistente.

Puoi usare l'oggetto di richiesta per fornire sia i parametri obbligatori sia quelli facoltativi;
Eseguire il metodo appropriato fornito dal client inviando l'oggetto di richiesta creato nella fase precedente.

Il AmazonDynamoDBClient client forniscePutItem, GetItemUpdateItem, e DeleteItem metodi per le CRUD operazioni.

Argomenti

Collocazione di un elemento

Il metodo PutItem carica un item nella tabella. Se l'item esiste, lo sostituisce per intero.

Nota

Se invece di sostituire l'intero item vuoi aggiornare solo attributi specifici, puoi utilizzare il metodo UpdateItem. Per ulteriori informazioni, consulta Aggiornamento di un elemento.

Di seguito sono riportati i passaggi per caricare un elemento utilizzando il livello basso. NETSDKAPI:

Creare un'istanza della classe AmazonDynamoDBClient.
fornisci i parametri obbligatori creando un istanza della classe PutItemRequest.

Per inserire un item, è necessario fornire il nome della tabella e l'item;
Eseguire il metodo PutItem fornendo l'oggetto PutItemRequest creato nella fase precedente.

Il seguente esempio C# mostra le fasi precedenti. L'esempio carica un item nella tabella ProductCatalog.

Esempio


AmazonDynamoDBClient client = new AmazonDynamoDBClient();
string tableName = "ProductCatalog";

var request = new PutItemRequest
{
   TableName = tableName,
   Item = new Dictionary<string, AttributeValue>()
      {
          { "Id", new AttributeValue { N = "201" }},
          { "Title", new AttributeValue { S = "Book 201 Title" }},
          { "ISBN", new AttributeValue { S = "11-11-11-11" }},
          { "Price", new AttributeValue { S = "20.00" }},
          {
            "Authors",
            new AttributeValue
            { SS = new List<string>{"Author1", "Author2"}   }
          }
      }
};
client.PutItem(request);

Nell'esempio precedente, carica un item libro che abbia gli attributi Id, Title, ISBN e Authors. Nota che Id è un attributo di tipo numerico, mentre tutti gli altri sono tipo stringa. Authors è un set di String.

Specifica dei parametri facoltativi

Puoi anche fornire parametri facoltativi usando l'oggetto PutItemRequest, come mostrato nel seguente esempio C#. L'esempio specifica i parametri facoltativi seguenti:

ExpressionAttributeNamesExpressionAttributeValues, e ConditionExpression specifica che l'articolo può essere sostituito solo se l'articolo esistente ha l'ISBNattributo con un valore specifico.
Il parametro ReturnValues per richiedere il vecchio item nella risposta.

Esempio


var request = new PutItemRequest
 {
   TableName = tableName,
   Item = new Dictionary<string, AttributeValue>()
               {
                   { "Id", new AttributeValue { N = "104" }},
                   { "Title", new AttributeValue { S = "Book 104  Title" }},
                   { "ISBN", new AttributeValue { S = "444-4444444444" }},
                   { "Authors",
                     new AttributeValue { SS = new List<string>{"Author3"}}}
               },
    // Optional parameters.
    ExpressionAttributeNames = new Dictionary<string,string>()
    {
        {"#I", "ISBN"}
    },
    ExpressionAttributeValues = new Dictionary<string, AttributeValue>()
    {
        {":isbn",new AttributeValue {S = "444-4444444444"}}
    },
    ConditionExpression = "#I = :isbn"

};
var response = client.PutItem(request);

Per ulteriori informazioni, vedere PutItem.

Ottenimento di un elemento

Il metodo GetItem recupera un item.

Nota

Per recuperare più item puoi usare il metodo BatchGetItem. Per ulteriori informazioni, consulta Ricezione in batch: ricezione di più elementi.

Di seguito sono riportati i passaggi per recuperare un elemento esistente utilizzando il livello basso AWS SDK for .NET API.

Creare un'istanza della classe AmazonDynamoDBClient.
fornisci i parametri obbligatori creando un istanza della classe GetItemRequest.

Per ottenere un item, è necessario fornire il nome della tabella e la chiave primaria dell'item.
Eseguire il metodo GetItem fornendo l'oggetto GetItemRequest creato nella fase precedente.

Il seguente esempio C# mostra le fasi precedenti. L'esempio recupera un item dalla tabella ProductCatalog.


AmazonDynamoDBClient client = new AmazonDynamoDBClient();
string tableName = "ProductCatalog";

var request = new GetItemRequest
 {
   TableName = tableName,
   Key = new Dictionary<string,AttributeValue>() { { "Id", new AttributeValue { N = "202" } } },
 };
 var response = client.GetItem(request);

// Check the response.
var result = response.GetItemResult;
var attributeMap = result.Item; // Attribute list in the response.

Specifica dei parametri facoltativi

Puoi anche fornire parametri facoltativi usando l'oggetto GetItemRequest, come mostrato nel seguente esempio C#. L'esempio specifica i parametri facoltativi seguenti:

Il parametro ProjectionExpression per specificare gli attributi da recuperare.
Il parametro ConsistentRead per eseguire una lettura estremamente coerente. Per ulteriori informazioni sulla lettura coerente, consulta Coerenza di lettura di DynamoDB.

Esempio


AmazonDynamoDBClient client = new AmazonDynamoDBClient();
string tableName = "ProductCatalog";

var request = new GetItemRequest
 {
   TableName = tableName,
   Key = new Dictionary<string,AttributeValue>() { { "Id", new AttributeValue { N = "202" } } },
   // Optional parameters.
   ProjectionExpression = "Id, ISBN, Title, Authors",
   ConsistentRead = true
 };

 var response = client.GetItem(request);

// Check the response.
var result = response.GetItemResult;
var attributeMap = result.Item;

Per ulteriori informazioni, vedere. GetItem

Aggiornamento di un elemento

Il metodo UpdateItem aggiorna un item esistente se presente. Puoi usare l'operazione UpdateItem per aggiornare i valori degli attributi esistenti, aggiungere nuovi attributi o eliminare attributi dalla raccolta esistente. Se non viene trovato l'item che dispone della chiave primaria specificata, viene aggiunto un nuovo item.

L'operazione UpdateItem usa le seguenti linee guida:

Se l'item non esiste, UpdateItem aggiunge un nuovo item usando la chiave primaria specificata nell'input.
Se l'item esiste, UpdateItem applica gli aggiornamenti come segue:
- sostituisce il valore dell'attributo esistente attraverso i valori dell'aggiornamento;
- se l'attributo che fornisci nell'input non esiste, viene aggiunto un nuovo attributo all'item;
- se l'attributo di input è nullo, viene eliminato l'attributo qualora presente;
- se utilizzi ADD per Action, puoi aggiungere valori a un set esistente (di stringhe o numeri) o aggiungere (se usi un numero positivo) o sottrarre (se usi un numero negativo) matematicamente dal valore dell'attributo numerico esistente.

Nota

L'operazione PutItem può anche eseguire un aggiornamento. Per ulteriori informazioni, consulta Collocazione di un elemento. Ad esempio, se chiami PutItem per caricare un item e la chiave primaria esiste, l'operazione PutItem sostituisce l'intero item. Se vi sono attributi nell'item esistente e quegli attributi non sono specificati nell'input, l'operazione PutItem li elimina. Tuttavia, UpdateItem aggiorna solo gli attributi di input specificati. Qualsiasi altro attributo esistente di quell'item rimarrà invariato.

Di seguito sono riportati i passaggi per aggiornare un elemento esistente utilizzando il livello basso. NETSDKAPI:

Creare un'istanza della classe AmazonDynamoDBClient.
fornisci i parametri obbligatori creando un istanza della classe UpdateItemRequest.

Questo è l'oggetto di richiesta in cui descrivi tutti gli aggiornamenti, come l'aggiunta di attributi, l'aggiornamento di quelli esistenti o l'eliminazione di attributi. Per rimuovere un attributo esistente, specifica il nome dell'attributo con valore nullo;
Eseguire il metodo UpdateItem fornendo l'oggetto UpdateItemRequest creato nella fase precedente.

Il seguente esempio di codice C# mostra le fasi precedenti. L'esempio aggiorna un item libro nella tabella ProductCatalog. Aggiunge un nuovo autore alla raccolta Authors ed elimina l'attributo ISBN esistente. Inoltre, riduce il prezzo di una unità.


AmazonDynamoDBClient client = new AmazonDynamoDBClient();
string tableName = "ProductCatalog";

var request = new UpdateItemRequest
{
    TableName = tableName,
    Key = new Dictionary<string,AttributeValue>() { { "Id", new AttributeValue { N = "202" } } },
    ExpressionAttributeNames = new Dictionary<string,string>()
    {
        {"#A", "Authors"},
        {"#P", "Price"},
        {"#NA", "NewAttribute"},
        {"#I", "ISBN"}
    },
    ExpressionAttributeValues = new Dictionary<string, AttributeValue>()
    {
        {":auth",new AttributeValue { SS = {"Author YY","Author ZZ"}}},
        {":p",new AttributeValue {N = "1"}},
        {":newattr",new AttributeValue {S = "someValue"}},
    },

    // This expression does the following:
    // 1) Adds two new authors to the list
    // 2) Reduces the price
    // 3) Adds a new attribute to the item
    // 4) Removes the ISBN attribute from the item
    UpdateExpression = "ADD #A :auth SET #P = #P - :p, #NA = :newattr REMOVE #I"
};
var response = client.UpdateItem(request);

Specifica dei parametri facoltativi

Puoi anche fornire parametri facoltativi usando l'oggetto UpdateItemRequest, come mostrato nel seguente esempio C#. Esso specifica i seguenti parametri opzionali:

ExpressionAttributeValues e ConditionExpression per specificare che il prezzo può essere aggiornato solo se il prezzo esistente è 20,00;
il parametro ReturnValues per richiedere l'item aggiornato nella risposta.

Esempio


AmazonDynamoDBClient client = new AmazonDynamoDBClient();
string tableName = "ProductCatalog";

var request = new UpdateItemRequest
{
    Key = new Dictionary<string,AttributeValue>() { { "Id", new AttributeValue { N = "202" } } },

    // Update price only if the current price is 20.00.
    ExpressionAttributeNames = new Dictionary<string,string>()
    {
        {"#P", "Price"}
    },
    ExpressionAttributeValues = new Dictionary<string, AttributeValue>()
    {
        {":newprice",new AttributeValue {N = "22"}},
        {":currprice",new AttributeValue {N = "20"}}
    },
    UpdateExpression = "SET #P = :newprice",
    ConditionExpression = "#P = :currprice",
    TableName = tableName,
    ReturnValues = "ALL_NEW" // Return all the attributes of the updated item.
};

var response = client.UpdateItem(request);

Per ulteriori informazioni, vedere UpdateItem.

Contatore atomico

Puoi usare il metodo updateItem per implementare un contatore atomico e incrementare o decrementare il valore di un attributo esistente senza interferire con altre richieste di scrittura. Per aggiornare un contatore atomico, usa updateItem con un attributo di tipo Number nel parametro UpdateExpression e ADD come Action.

Il seguente esempio ne dimostra l'uso, incrementando l'attributo Quantity di uno.


AmazonDynamoDBClient client = new AmazonDynamoDBClient();
string tableName = "ProductCatalog";

var request = new UpdateItemRequest
{
    Key = new Dictionary<string, AttributeValue>() { { "Id", new AttributeValue { N = "121" } } },
    ExpressionAttributeNames = new Dictionary<string, string>()
    {
        {"#Q", "Quantity"}
    },
    ExpressionAttributeValues = new Dictionary<string, AttributeValue>()
    {
        {":incr",new AttributeValue {N = "1"}}
    },
    UpdateExpression = "SET #Q = #Q + :incr",
    TableName = tableName
};

var response = client.UpdateItem(request);

Eliminazione di un elemento

Il metodo DeleteItem elimina un item da una tabella.

Di seguito sono riportati i passaggi per eliminare un elemento utilizzando il livello basso. NETSDKAPI.

Creare un'istanza della classe AmazonDynamoDBClient.
fornisci i parametri obbligatori creando un istanza della classe DeleteItemRequest.

Per eliminare un item, sono necessari il nome della tabella e la chiave primaria dell'item;
Eseguire il metodo DeleteItem fornendo l'oggetto DeleteItemRequest creato nella fase precedente.

Esempio


AmazonDynamoDBClient client = new AmazonDynamoDBClient();
string tableName = "ProductCatalog";

var request = new DeleteItemRequest
{
    TableName = tableName,
    Key = new Dictionary<string,AttributeValue>() { { "Id", new AttributeValue { N = "201" } } },
};

var response = client.DeleteItem(request);

Specifica dei parametri facoltativi

Puoi anche fornire parametri facoltativi usando l'oggetto DeleteItemRequest, come mostrato nel seguente esempio di codice C#. Esso specifica i seguenti parametri opzionali:

ExpressionAttributeValuese ConditionExpression per specificare che l'elemento del libro può essere eliminato solo se non è più in pubblicazione (il valore dell' InPublication attributo è falso).
il parametro ReturnValues per richiedere l'item eliminato nella risposta.

Esempio


var request = new DeleteItemRequest
{
    TableName = tableName,
    Key = new Dictionary<string,AttributeValue>() { { "Id", new AttributeValue { N = "201" } } },

    // Optional parameters.
    ReturnValues = "ALL_OLD",
    ExpressionAttributeNames = new Dictionary<string, string>()
    {
        {"#IP", "InPublication"}
    },
    ExpressionAttributeValues = new Dictionary<string, AttributeValue>()
    {
        {":inpub",new AttributeValue {BOOL = false}}
    },
    ConditionExpression = "#IP = :inpub"
};

var response = client.DeleteItem(request);

Per ulteriori informazioni, vedere DeleteItem.

Scrittura in batch: collocazione ed eliminazione di più elementi

La scrittura in batch fa riferimento alla collocazione e all'eliminazione di più item in un batch. Il metodo BatchWriteItem ti consente di inserire ed eliminare più item da una o più tabelle con un'unica chiamata. Di seguito sono riportati i passaggi per recuperare più elementi utilizzando il livello basso. NETSDKAPI.

Creare un'istanza della classe AmazonDynamoDBClient.
descrivi tutte le operazioni di inserimento ed eliminazione creando un istanza della classe BatchWriteItemRequest;
Eseguire il metodo BatchWriteItem fornendo l'oggetto BatchWriteItemRequest creato nella fase precedente.
Elabora la risposta. Dovresti controllare se erano presenti item di richiesta non elaborati restituiti nella risposta. Questo potrebbe accadere se raggiungi la quota di throughput assegnata o si verifica un altro errore transitorio. Inoltre, DynamoDB limita la dimensione della richiesta e il numero di operazioni che possono essere specificate in una richiesta. Se si superano questi limiti, DynamoDB rifiuta la richiesta. Per ulteriori informazioni, vedere BatchWriteItem.

Il seguente esempio di codice C# mostra le fasi precedenti. L'esempio crea un BatchWriteItemRequest per eseguire le seguenti operazioni di scrittura:

inserisci un item nella tabella Forum;
inserisce ed elimina un item dalla tabella Thread.

Il codice quindi esegue BatchWriteItem per l'operazione in batch.


AmazonDynamoDBClient client = new AmazonDynamoDBClient();

string table1Name = "Forum";
string table2Name = "Thread";

var request = new BatchWriteItemRequest
 {
   RequestItems = new Dictionary<string, List<WriteRequest>>
    {
      {
        table1Name, new List<WriteRequest>
        {
          new WriteRequest
          {
             PutRequest = new PutRequest
             {
                Item = new Dictionary<string,AttributeValue>
                {
                  { "Name", new AttributeValue { S = "Amazon S3 forum" } },
                  { "Threads", new AttributeValue { N = "0" }}
                }
             }
          }
        }
      } ,
      {
        table2Name, new List<WriteRequest>
        {
          new WriteRequest
          {
            PutRequest = new PutRequest
            {
               Item = new Dictionary<string,AttributeValue>
               {
                 { "ForumName", new AttributeValue { S = "Amazon S3 forum" } },
                 { "Subject", new AttributeValue { S = "My sample question" } },
                 { "Message", new AttributeValue { S = "Message Text." } },
                 { "KeywordTags", new AttributeValue { SS = new List<string> { "Amazon S3", "Bucket" }  } }
               }
            }
          },
          new WriteRequest
          {
             DeleteRequest = new DeleteRequest
             {
                Key = new Dictionary<string,AttributeValue>()
                {
                   { "ForumName", new AttributeValue { S = "Some forum name" } },
                   { "Subject", new AttributeValue { S = "Some subject" } }
                }
             }
          }
        }
      }
    }
 };
response = client.BatchWriteItem(request);

Per un esempio di utilizzo, consulta Esempio: operazioni in batch utilizzando il AWS SDK for .NET livello basso API.

Ricezione in batch: ricezione di più elementi

Il metodo BatchGetItem ti consente di recuperare più item da una o più tabelle.

Nota

Per recuperare un singolo item puoi usare il metodo GetItem.

Di seguito sono riportati i passaggi per recuperare più elementi utilizzando il livello basso AWS SDK for .NET API.

Creare un'istanza della classe AmazonDynamoDBClient.
fornisci i parametri obbligatori creando un istanza della classe BatchGetItemRequest.

Per recuperare più item, sono necessari il nome della tabella e un elenco dei valori della chiave primaria.
Eseguire il metodo BatchGetItem fornendo l'oggetto BatchGetItemRequest creato nella fase precedente.
Elabora la risposta. Dovresti controllare se erano presenti chiavi non elaborate. Questo potrebbe accadere se hai raggiunto la quota di throughput assegnata o alcuni errori di transizione.

Il seguente esempio di codice C# mostra le fasi precedenti. L'esempio recupera gli elementi da due tabelle, Forum e Thread. La richiesta specifica due item nella tabella Forum e tre nella tabella Thread. La risposta include item da entrambe le tabelle. Il codice mostra come puoi elaborare la risposta.


AmazonDynamoDBClient client = new AmazonDynamoDBClient();

string table1Name = "Forum";
string table2Name = "Thread";

var request = new BatchGetItemRequest
{
  RequestItems = new Dictionary<string, KeysAndAttributes>()
  {
    { table1Name,
      new KeysAndAttributes
      {
        Keys = new List<Dictionary<string, AttributeValue>>()
        {
          new Dictionary<string, AttributeValue>()
          {
            { "Name", new AttributeValue { S = "DynamoDB" } }
          },
          new Dictionary<string, AttributeValue>()
          {
            { "Name", new AttributeValue { S = "Amazon S3" } }
          }
        }
      }
    },
    {
      table2Name,
      new KeysAndAttributes
      {
        Keys = new List<Dictionary<string, AttributeValue>>()
        {
          new Dictionary<string, AttributeValue>()
          {
            { "ForumName", new AttributeValue { S = "DynamoDB" } },
            { "Subject", new AttributeValue { S = "DynamoDB Thread 1" } }
          },
          new Dictionary<string, AttributeValue>()
          {
            { "ForumName", new AttributeValue { S = "DynamoDB" } },
            { "Subject", new AttributeValue { S = "DynamoDB Thread 2" } }
          },
          new Dictionary<string, AttributeValue>()
          {
            { "ForumName", new AttributeValue { S = "Amazon S3" } },
            { "Subject", new AttributeValue { S = "Amazon S3 Thread 1" } }
          }
        }
      }
    }
  }
};

var response = client.BatchGetItem(request);

// Check the response.
var result = response.BatchGetItemResult;
var responses = result.Responses; // The attribute list in the response.

var table1Results = responses[table1Name];
Console.WriteLine("Items in table {0}" + table1Name);
foreach (var item1 in table1Results.Items)
{
  PrintItem(item1);
}

var table2Results = responses[table2Name];
Console.WriteLine("Items in table {1}" + table2Name);
foreach (var item2 in table2Results.Items)
{
  PrintItem(item2);
}
// Any unprocessed keys? could happen if you exceed ProvisionedThroughput or some other error.
Dictionary<string, KeysAndAttributes> unprocessedKeys = result.UnprocessedKeys;
foreach (KeyValuePair<string, KeysAndAttributes> pair in unprocessedKeys)
{
    Console.WriteLine(pair.Key, pair.Value);
}

Specifica dei parametri facoltativi

Puoi anche fornire parametri facoltativi usando l'oggetto BatchGetItemRequest, come mostrato nel seguente esempio di codice C#. L'esempio recupera un item dalla tabella Forum. Esso specifica il seguente parametro opzionale:

Il parametro ProjectionExpression per specificare gli attributi da recuperare.

Esempio


AmazonDynamoDBClient client = new AmazonDynamoDBClient();

string table1Name = "Forum";

var request = new BatchGetItemRequest
{
  RequestItems = new Dictionary<string, KeysAndAttributes>()
  {
    { table1Name,
      new KeysAndAttributes
      {
        Keys = new List<Dictionary<string, AttributeValue>>()
        {
          new Dictionary<string, AttributeValue>()
          {
            { "Name", new AttributeValue { S = "DynamoDB" } }
          },
          new Dictionary<string, AttributeValue>()
          {
            { "Name", new AttributeValue { S = "Amazon S3" } }
          }
        }
      },
      // Optional - name of an attribute to retrieve.
      ProjectionExpression = "Title"
    }
  }
};

var response = client.BatchGetItem(request);

Per ulteriori informazioni, vedere. BatchGetItem

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Esempio: gestione degli attributi di tipo binario - Documento Java API

Esempio: CRUD operazioni -. NETdi basso livello API