# Working with items: .NET Working with items: .NET You can use the Amazon SDK for .NET low-level API to perform typical create, read, update, and delete (CRUD) operations on an item in a table. The following are the common steps that you follow to perform data CRUD operations using the .NET low-level API: 1. Create an instance of the `AmazonDynamoDBClient` class (the client). 1. Provide the operation-specific required parameters in a corresponding request object. For example, use the `PutItemRequest` request object when uploading an item and use the `GetItemRequest` request object when retrieving an existing item. You can use the request object to provide both the required and optional parameters. 1. Run the appropriate method provided by the client by passing in the request object that you created in the preceding step. The `AmazonDynamoDBClient` client provides `PutItem`, `GetItem`, `UpdateItem`, and `DeleteItem` methods for the CRUD operations. **Topics** + [ ## Putting an item ](#PutItemLowLevelAPIDotNet) + [ ## Getting an item ](#GetItemLowLevelDotNET) + [ ## Updating an item ](#UpdateItemLowLevelDotNet) + [ ## Atomic counter ](#AtomicCounterLowLevelDotNet) + [ ## Deleting an item ](#DeleteMidLevelDotNet) + [ ## Batch write: Putting and deleting multiple items ](#BatchWriteLowLevelDotNet) + [ ## Batch get: Getting multiple items ](#BatchGetLowLevelDotNet) + [ # Example: CRUD operations using the Amazon SDK for .NET low-level API ](LowLevelDotNetItemsExample.md) + [ # Example: Batch operations using the Amazon SDK for .NET low-level API ](batch-operation-lowlevel-dotnet.md) + [ # Example: Handling binary type attributes using the Amazon SDK for .NET low-level API ](LowLevelDotNetBinaryTypeExample.md) ## Putting an item The `PutItem` method uploads an item to a table. If the item exists, it replaces the entire item. **Note** Instead of replacing the entire item, if you want to update only specific attributes, you can use the `UpdateItem` method. For more information, see [Updating an item](#UpdateItemLowLevelDotNet). The following are the steps to upload an item using the low-level .NET SDK API: 1. Create an instance of the `AmazonDynamoDBClient` class. 1. Provide the required parameters by creating an instance of the `PutItemRequest` class. To put an item, you must provide the table name and the item. 1. Run the `PutItem` method by providing the `PutItemRequest` object that you created in the preceding step. The following C\$1 example demonstrates the preceding steps. The example uploads an item to the `ProductCatalog` table. **Example** ``` AmazonDynamoDBClient client = new AmazonDynamoDBClient(); string tableName = "ProductCatalog"; var request = new PutItemRequest { TableName = tableName, Item = new Dictionary() { { "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{"Author1", "Author2"} } } } }; client.PutItem(request); ``` In the preceding example, you upload a book item that has the `Id`, `Title`, `ISBN`, and `Authors` attributes. Note that `Id` is a numeric type attribute, and all other attributes are of the string type. Authors is a `String` set. ### Specifying optional parameters You can also provide optional parameters using the `PutItemRequest` object as shown in the following C\$1 example. The example specifies the following optional parameters: + `ExpressionAttributeNames`, `ExpressionAttributeValues`, and `ConditionExpression` specify that the item can be replaced only if the existing item has the ISBN attribute with a specific value. + `ReturnValues` parameter to request the old item in the response. **Example** ``` var request = new PutItemRequest { TableName = tableName, Item = new Dictionary() { { "Id", new AttributeValue { N = "104" }}, { "Title", new AttributeValue { S = "Book 104 Title" }}, { "ISBN", new AttributeValue { S = "444-4444444444" }}, { "Authors", new AttributeValue { SS = new List{"Author3"}}} }, // Optional parameters. ExpressionAttributeNames = new Dictionary() { {"#I", "ISBN"} }, ExpressionAttributeValues = new Dictionary() { {":isbn",new AttributeValue {S = "444-4444444444"}} }, ConditionExpression = "#I = :isbn" }; var response = client.PutItem(request); ``` For more information, see [PutItem](https://docs.amazonaws.cn/amazondynamodb/latest/APIReference/API_PutItem.html). ## Getting an item The `GetItem` method retrieves an item. **Note** To retrieve multiple items, you can use the `BatchGetItem` method. For more information, see [Batch get: Getting multiple items](#BatchGetLowLevelDotNet). The following are the steps to retrieve an existing item using the low-level Amazon SDK for .NET API. 1. Create an instance of the `AmazonDynamoDBClient` class. 1. Provide the required parameters by creating an instance of the `GetItemRequest` class. To get an item, you must provide the table name and primary key of the item. 1. Run the `GetItem` method by providing the `GetItemRequest` object that you created in the preceding step. The following C\$1 example demonstrates the preceding steps. The example retrieves an item from the `ProductCatalog` table. ``` AmazonDynamoDBClient client = new AmazonDynamoDBClient(); string tableName = "ProductCatalog"; var request = new GetItemRequest { TableName = tableName, Key = new Dictionary() { { "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. ``` ### Specifying optional parameters You can also provide optional parameters using the `GetItemRequest` object, as shown in the following C\$1 example. The sample specifies the following optional parameters: + `ProjectionExpression` parameter to specify the attributes to retrieve. + `ConsistentRead` parameter to perform a strongly consistent read. To learn more read consistency, see [DynamoDB read consistency](HowItWorks.ReadConsistency.md). **Example** ``` AmazonDynamoDBClient client = new AmazonDynamoDBClient(); string tableName = "ProductCatalog"; var request = new GetItemRequest { TableName = tableName, Key = new Dictionary() { { "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; ``` For more information, see [GetItem](https://docs.amazonaws.cn/amazondynamodb/latest/APIReference/API_GetItem.html). ## Updating an item The `UpdateItem` method updates an existing item if it is present. You can use the `UpdateItem` operation to update existing attribute values, add new attributes, or delete attributes from the existing collection. If the item that has the specified primary key is not found, it adds a new item. The `UpdateItem` operation uses the following guidelines: + If the item does not exist, `UpdateItem` adds a new item using the primary key that is specified in the input. + If the item exists, `UpdateItem` applies the updates as follows: + Replaces the existing attribute values by the values in the update. + If the attribute that you provide in the input does not exist, it adds a new attribute to the item. + If the input attribute is null, it deletes the attribute, if it is present. + If you use `ADD` for the `Action`, you can add values to an existing set (string or number set), or mathematically add (use a positive number) or subtract (use a negative number) from the existing numeric attribute value. **Note** The `PutItem` operation also can perform an update. For more information, see [Putting an item](#PutItemLowLevelAPIDotNet). For example, if you call `PutItem` to upload an item and the primary key exists, the `PutItem` operation replaces the entire item. If there are attributes in the existing item and those attributes are not specified in the input, the `PutItem` operation deletes those attributes. However, `UpdateItem` updates only the specified input attributes. Any other existing attributes of that item remain unchanged. The following are the steps to update an existing item using the low-level .NET SDK API: 1. Create an instance of the `AmazonDynamoDBClient` class. 1. Provide the required parameters by creating an instance of the `UpdateItemRequest` class. This is the request object in which you describe all the updates, such as add attributes, update existing attributes, or delete attributes. To delete an existing attribute, specify the attribute name with null value. 1. Run the `UpdateItem` method by providing the `UpdateItemRequest` object that you created in the preceding step. The following C\$1 code example demonstrates the preceding steps. The example updates a book item in the `ProductCatalog` table. It adds a new author to the `Authors` collection, and deletes the existing `ISBN` attribute. It also reduces the price by one. ``` AmazonDynamoDBClient client = new AmazonDynamoDBClient(); string tableName = "ProductCatalog"; var request = new UpdateItemRequest { TableName = tableName, Key = new Dictionary() { { "Id", new AttributeValue { N = "202" } } }, ExpressionAttributeNames = new Dictionary() { {"#A", "Authors"}, {"#P", "Price"}, {"#NA", "NewAttribute"}, {"#I", "ISBN"} }, ExpressionAttributeValues = new Dictionary() { {":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); ``` ### Specifying optional parameters You can also provide optional parameters using the `UpdateItemRequest` object, as shown in the following C\$1 example. It specifies the following optional parameters: + `ExpressionAttributeValues` and `ConditionExpression` to specify that the price can be updated only if the existing price is 20.00. + `ReturnValues` parameter to request the updated item in the response. **Example** ``` AmazonDynamoDBClient client = new AmazonDynamoDBClient(); string tableName = "ProductCatalog"; var request = new UpdateItemRequest { Key = new Dictionary() { { "Id", new AttributeValue { N = "202" } } }, // Update price only if the current price is 20.00. ExpressionAttributeNames = new Dictionary() { {"#P", "Price"} }, ExpressionAttributeValues = new Dictionary() { {":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); ``` For more information, see [UpdateItem](https://docs.amazonaws.cn/amazondynamodb/latest/APIReference/API_UpdateItem.html). ## Atomic counter You can use `updateItem` to implement an atomic counter, where you increment or decrement the value of an existing attribute without interfering with other write requests. To update an atomic counter, use `updateItem` with an attribute of type `Number` in the `UpdateExpression` parameter, and `ADD` as the `Action`. The following example demonstrates this, incrementing the `Quantity` attribute by one. ``` AmazonDynamoDBClient client = new AmazonDynamoDBClient(); string tableName = "ProductCatalog"; var request = new UpdateItemRequest { Key = new Dictionary() { { "Id", new AttributeValue { N = "121" } } }, ExpressionAttributeNames = new Dictionary() { {"#Q", "Quantity"} }, ExpressionAttributeValues = new Dictionary() { {":incr",new AttributeValue {N = "1"}} }, UpdateExpression = "SET #Q = #Q + :incr", TableName = tableName }; var response = client.UpdateItem(request); ``` ## Deleting an item The `DeleteItem` method deletes an item from a table. The following are the steps to delete an item using the low-level .NET SDK API. 1. Create an instance of the `AmazonDynamoDBClient` class. 1. Provide the required parameters by creating an instance of the `DeleteItemRequest` class. To delete an item, the table name and item's primary key are required. 1. Run the `DeleteItem` method by providing the `DeleteItemRequest` object that you created in the preceding step. **Example** ``` AmazonDynamoDBClient client = new AmazonDynamoDBClient(); string tableName = "ProductCatalog"; var request = new DeleteItemRequest { TableName = tableName, Key = new Dictionary() { { "Id", new AttributeValue { N = "201" } } }, }; var response = client.DeleteItem(request); ``` ### Specifying optional parameters You can also provide optional parameters using the `DeleteItemRequest` object as shown in the following C\$1 code example. It specifies the following optional parameters: + `ExpressionAttributeValues` and `ConditionExpression` to specify that the book item can be deleted only if it is no longer in publication (the InPublication attribute value is false). + `ReturnValues` parameter to request the deleted item in the response. **Example** ``` var request = new DeleteItemRequest { TableName = tableName, Key = new Dictionary() { { "Id", new AttributeValue { N = "201" } } }, // Optional parameters. ReturnValues = "ALL_OLD", ExpressionAttributeNames = new Dictionary() { {"#IP", "InPublication"} }, ExpressionAttributeValues = new Dictionary() { {":inpub",new AttributeValue {BOOL = false}} }, ConditionExpression = "#IP = :inpub" }; var response = client.DeleteItem(request); ``` For more information, see [DeleteItem](https://docs.amazonaws.cn/amazondynamodb/latest/APIReference/API_DeleteItem.html). ## Batch write: Putting and deleting multiple items *Batch write* refers to putting and deleting multiple items in a batch. The `BatchWriteItem` method enables you to put and delete multiple items from one or more tables in a single call. The following are the steps to retrieve multiple items using the low-level .NET SDK API. 1. Create an instance of the `AmazonDynamoDBClient` class. 1. Describe all the put and delete operations by creating an instance of the `BatchWriteItemRequest` class. 1. Run the `BatchWriteItem` method by providing the `BatchWriteItemRequest` object that you created in the preceding step. 1. Process the response. You should check if there were any unprocessed request items returned in the response. This could happen if you reach the provisioned throughput quota or some other transient error. Also, DynamoDB limits the request size and the number of operations you can specify in a request. If you exceed these limits, DynamoDB rejects the request. For more information, see [BatchWriteItem](https://docs.amazonaws.cn/amazondynamodb/latest/APIReference/API_BatchWriteItem.html). The following C\$1 code example demonstrates the preceding steps. The example creates a `BatchWriteItemRequest` to perform the following write operations: + Put an item in `Forum` table. + Put and delete an item from `Thread` table. The code runs `BatchWriteItem` to perform a batch operation. ``` AmazonDynamoDBClient client = new AmazonDynamoDBClient(); string table1Name = "Forum"; string table2Name = "Thread"; var request = new BatchWriteItemRequest { RequestItems = new Dictionary> { { table1Name, new List { new WriteRequest { PutRequest = new PutRequest { Item = new Dictionary { { "Name", new AttributeValue { S = "Amazon S3 forum" } }, { "Threads", new AttributeValue { N = "0" }} } } } } } , { table2Name, new List { new WriteRequest { PutRequest = new PutRequest { Item = new Dictionary { { "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 { "Amazon S3", "Bucket" } } } } } }, new WriteRequest { DeleteRequest = new DeleteRequest { Key = new Dictionary() { { "ForumName", new AttributeValue { S = "Some forum name" } }, { "Subject", new AttributeValue { S = "Some subject" } } } } } } } } }; response = client.BatchWriteItem(request); ``` For a working example, see [Example: Batch operations using the Amazon SDK for .NET low-level API](batch-operation-lowlevel-dotnet.md). ## Batch get: Getting multiple items The `BatchGetItem` method enables you to retrieve multiple items from one or more tables. **Note** To retrieve a single item, you can use the `GetItem` method. The following are the steps to retrieve multiple items using the low-level Amazon SDK for .NET API. 1. Create an instance of the `AmazonDynamoDBClient` class. 1. Provide the required parameters by creating an instance of the `BatchGetItemRequest` class. To retrieve multiple items, the table name and a list of primary key values are required. 1. Run the `BatchGetItem` method by providing the `BatchGetItemRequest` object that you created in the preceding step. 1. Process the response. You should check if there were any unprocessed keys, which could happen if you reach the provisioned throughput quota or some other transient error. The following C\$1 code example demonstrates the preceding steps. The example retrieves items from two tables, `Forum` and `Thread`. The request specifies two items in the `Forum` and three items in the `Thread` table. The response includes items from both of the tables. The code shows how you can process the response. ``` AmazonDynamoDBClient client = new AmazonDynamoDBClient(); string table1Name = "Forum"; string table2Name = "Thread"; var request = new BatchGetItemRequest { RequestItems = new Dictionary() { { table1Name, new KeysAndAttributes { Keys = new List>() { new Dictionary() { { "Name", new AttributeValue { S = "DynamoDB" } } }, new Dictionary() { { "Name", new AttributeValue { S = "Amazon S3" } } } } } }, { table2Name, new KeysAndAttributes { Keys = new List>() { new Dictionary() { { "ForumName", new AttributeValue { S = "DynamoDB" } }, { "Subject", new AttributeValue { S = "DynamoDB Thread 1" } } }, new Dictionary() { { "ForumName", new AttributeValue { S = "DynamoDB" } }, { "Subject", new AttributeValue { S = "DynamoDB Thread 2" } } }, new Dictionary() { { "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 unprocessedKeys = result.UnprocessedKeys; foreach (KeyValuePair pair in unprocessedKeys) { Console.WriteLine(pair.Key, pair.Value); } ``` ### Specifying optional parameters You can also provide optional parameters using the `BatchGetItemRequest` object as shown in the following C\$1 code example. The example retrieves two items from the `Forum` table. It specifies the following optional parameter: + `ProjectionExpression` parameter to specify the attributes to retrieve. **Example** ``` AmazonDynamoDBClient client = new AmazonDynamoDBClient(); string table1Name = "Forum"; var request = new BatchGetItemRequest { RequestItems = new Dictionary() { { table1Name, new KeysAndAttributes { Keys = new List>() { new Dictionary() { { "Name", new AttributeValue { S = "DynamoDB" } } }, new Dictionary() { { "Name", new AttributeValue { S = "Amazon S3" } } } } }, // Optional - name of an attribute to retrieve. ProjectionExpression = "Title" } } }; var response = client.BatchGetItem(request); ``` For more information, see [BatchGetItem](https://docs.amazonaws.cn/amazondynamodb/latest/APIReference/API_BatchGetItem.html). # Example: CRUD operations using the Amazon SDK for .NET low-level API Example: CRUD operations - .NET low-level API The following C\$1 code example illustrates CRUD operations on an Amazon DynamoDB item. The example adds an item to the `ProductCatalog` table, retrieves it, performs various updates, and finally deletes the item. If you haven't created this table, you can also create it programmatically. For more information, see [Creating example tables and uploading data using the Amazon SDK for .NET](AppendixSampleDataCodeDotNET.md). For step-by-step instructions for testing the following sample, see [.NET code examples](CodeSamples.DotNet.md). **Example** ``` using System; using System.Collections.Generic; using Amazon.DynamoDBv2; using Amazon.DynamoDBv2.Model; using Amazon.Runtime; using Amazon.SecurityToken; namespace com.amazonaws.codesamples { class LowLevelItemCRUDExample { private static string tableName = "ProductCatalog"; private static AmazonDynamoDBClient client = new AmazonDynamoDBClient(); static void Main(string[] args) { try { CreateItem(); RetrieveItem(); // Perform various updates. UpdateMultipleAttributes(); UpdateExistingAttributeConditionally(); // Delete item. DeleteItem(); Console.WriteLine("To continue, press Enter"); Console.ReadLine(); } catch (Exception e) { Console.WriteLine(e.Message); Console.WriteLine("To continue, press Enter"); Console.ReadLine(); } } private static void CreateItem() { var request = new PutItemRequest { TableName = tableName, Item = new Dictionary() { { "Id", new AttributeValue { N = "1000" }}, { "Title", new AttributeValue { S = "Book 201 Title" }}, { "ISBN", new AttributeValue { S = "11-11-11-11" }}, { "Authors", new AttributeValue { SS = new List{"Author1", "Author2" } }}, { "Price", new AttributeValue { N = "20.00" }}, { "Dimensions", new AttributeValue { S = "8.5x11.0x.75" }}, { "InPublication", new AttributeValue { BOOL = false } } } }; client.PutItem(request); } private static void RetrieveItem() { var request = new GetItemRequest { TableName = tableName, Key = new Dictionary() { { "Id", new AttributeValue { N = "1000" } } }, ProjectionExpression = "Id, ISBN, Title, Authors", ConsistentRead = true }; var response = client.GetItem(request); // Check the response. var attributeList = response.Item; // attribute list in the response. Console.WriteLine("\nPrinting item after retrieving it ............"); PrintItem(attributeList); } private static void UpdateMultipleAttributes() { var request = new UpdateItemRequest { Key = new Dictionary() { { "Id", new AttributeValue { N = "1000" } } }, // Perform the following updates: // 1) Add two new authors to the list // 1) Set a new attribute // 2) Remove the ISBN attribute ExpressionAttributeNames = new Dictionary() { {"#A","Authors"}, {"#NA","NewAttribute"}, {"#I","ISBN"} }, ExpressionAttributeValues = new Dictionary() { {":auth",new AttributeValue { SS = {"Author YY", "Author ZZ"} }}, {":new",new AttributeValue { S = "New Value" }} }, UpdateExpression = "ADD #A :auth SET #NA = :new REMOVE #I", TableName = tableName, ReturnValues = "ALL_NEW" // Give me all attributes of the updated item. }; var response = client.UpdateItem(request); // Check the response. var attributeList = response.Attributes; // attribute list in the response. // print attributeList. Console.WriteLine("\nPrinting item after multiple attribute update ............"); PrintItem(attributeList); } private static void UpdateExistingAttributeConditionally() { var request = new UpdateItemRequest { Key = new Dictionary() { { "Id", new AttributeValue { N = "1000" } } }, ExpressionAttributeNames = new Dictionary() { {"#P", "Price"} }, ExpressionAttributeValues = new Dictionary() { {":newprice",new AttributeValue { N = "22.00" }}, {":currprice",new AttributeValue { N = "20.00" }} }, // This updates price only if current price is 20.00. UpdateExpression = "SET #P = :newprice", ConditionExpression = "#P = :currprice", TableName = tableName, ReturnValues = "ALL_NEW" // Give me all attributes of the updated item. }; var response = client.UpdateItem(request); // Check the response. var attributeList = response.Attributes; // attribute list in the response. Console.WriteLine("\nPrinting item after updating price value conditionally ............"); PrintItem(attributeList); } private static void DeleteItem() { var request = new DeleteItemRequest { TableName = tableName, Key = new Dictionary() { { "Id", new AttributeValue { N = "1000" } } }, // Return the entire item as it appeared before the update. ReturnValues = "ALL_OLD", ExpressionAttributeNames = new Dictionary() { {"#IP", "InPublication"} }, ExpressionAttributeValues = new Dictionary() { {":inpub",new AttributeValue { BOOL = false }} }, ConditionExpression = "#IP = :inpub" }; var response = client.DeleteItem(request); // Check the response. var attributeList = response.Attributes; // Attribute list in the response. // Print item. Console.WriteLine("\nPrinting item that was just deleted ............"); PrintItem(attributeList); } private static void PrintItem(Dictionary attributeList) { foreach (KeyValuePair kvp in attributeList) { string attributeName = kvp.Key; AttributeValue value = kvp.Value; Console.WriteLine( attributeName + " " + (value.S == null ? "" : "S=[" + value.S + "]") + (value.N == null ? "" : "N=[" + value.N + "]") + (value.SS == null ? "" : "SS=[" + string.Join(",", value.SS.ToArray()) + "]") + (value.NS == null ? "" : "NS=[" + string.Join(",", value.NS.ToArray()) + "]") ); } Console.WriteLine("************************************************"); } } } ``` # Example: Batch operations using the Amazon SDK for .NET low-level API Example: Batch operations - .NET low-level API **Topics** + [ ## Example: Batch write operation using the Amazon SDK for .NET low-level API ](#batch-write-low-level-dotnet) + [ ## Example: Batch get operation using the Amazon SDK for .NET low-level API ](#LowLevelDotNetBatchGet) This section provides examples of batch operations, *batch write* and *batch get*, that Amazon DynamoDB supports. ## Example: Batch write operation using the Amazon SDK for .NET low-level API Example: Batch write - .NET low-level API The following C\$1 code example uses the `BatchWriteItem` method to perform the following put and delete operations: + Put one item in the `Forum` table. + Put one item and delete one item from the `Thread` table. You can specify any number of put and delete requests against one or more tables when creating your batch write request. However, DynamoDB `BatchWriteItem` limits the size of a batch write request and the number of put and delete operations in a single batch write operation. For more information, see [BatchWriteItem](https://docs.amazonaws.cn/amazondynamodb/latest/APIReference/API_BatchWriteItem.html). If your request exceeds these limits, your request is rejected. If your table does not have sufficient provisioned throughput to serve this request, the unprocessed request items are returned in the response. The following example checks the response to see if it has any unprocessed request items. If it does, it loops back and resends the `BatchWriteItem` request with unprocessed items in the request. You can also create these sample tables and upload sample data programmatically. For more information, see [Creating example tables and uploading data using the Amazon SDK for .NET](AppendixSampleDataCodeDotNET.md). For step-by-step instructions for testing the following sample, see [.NET code examples](CodeSamples.DotNet.md). **Example** ``` using System; using System.Collections.Generic; using Amazon.DynamoDBv2; using Amazon.DynamoDBv2.Model; using Amazon.Runtime; namespace com.amazonaws.codesamples { class LowLevelBatchWrite { private static string table1Name = "Forum"; private static string table2Name = "Thread"; private static AmazonDynamoDBClient client = new AmazonDynamoDBClient(); static void Main(string[] args) { try { TestBatchWrite(); } catch (AmazonServiceException e) { Console.WriteLine(e.Message); } catch (Exception e) { Console.WriteLine(e.Message); } Console.WriteLine("To continue, press Enter"); Console.ReadLine(); } private static void TestBatchWrite() { var request = new BatchWriteItemRequest { ReturnConsumedCapacity = "TOTAL", RequestItems = new Dictionary> { { table1Name, new List { new WriteRequest { PutRequest = new PutRequest { Item = new Dictionary { { "Name", new AttributeValue { S = "S3 forum" } }, { "Threads", new AttributeValue { N = "0" }} } } } } }, { table2Name, new List { new WriteRequest { PutRequest = new PutRequest { Item = new Dictionary { { "ForumName", new AttributeValue { S = "S3 forum" } }, { "Subject", new AttributeValue { S = "My sample question" } }, { "Message", new AttributeValue { S = "Message Text." } }, { "KeywordTags", new AttributeValue { SS = new List { "S3", "Bucket" } } } } } }, new WriteRequest { // For the operation to delete an item, if you provide a primary key value // that does not exist in the table, there is no error, it is just a no-op. DeleteRequest = new DeleteRequest { Key = new Dictionary() { { "ForumName", new AttributeValue { S = "Some partition key value" } }, { "Subject", new AttributeValue { S = "Some sort key value" } } } } } } } } }; CallBatchWriteTillCompletion(request); } private static void CallBatchWriteTillCompletion(BatchWriteItemRequest request) { BatchWriteItemResponse response; int callCount = 0; do { Console.WriteLine("Making request"); response = client.BatchWriteItem(request); callCount++; // Check the response. var tableConsumedCapacities = response.ConsumedCapacity; var unprocessed = response.UnprocessedItems; Console.WriteLine("Per-table consumed capacity"); foreach (var tableConsumedCapacity in tableConsumedCapacities) { Console.WriteLine("{0} - {1}", tableConsumedCapacity.TableName, tableConsumedCapacity.CapacityUnits); } Console.WriteLine("Unprocessed"); foreach (var unp in unprocessed) { Console.WriteLine("{0} - {1}", unp.Key, unp.Value.Count); } Console.WriteLine(); // For the next iteration, the request will have unprocessed items. request.RequestItems = unprocessed; } while (response.UnprocessedItems.Count > 0); Console.WriteLine("Total # of batch write API calls made: {0}", callCount); } } } ``` ## Example: Batch get operation using the Amazon SDK for .NET low-level API Example: Batch get - .NET low-level API The following C\$1 code example uses the `BatchGetItem` method to retrieve multiple items from the `Forum` and the `Thread` tables in Amazon DynamoDB. The `BatchGetItemRequest` specifies the table names and a list of primary keys for each table. The example processes the response by printing the items retrieved. For step-by-step instructions for testing the following sample, see [.NET code examples](CodeSamples.DotNet.md). **Example** ``` using System; using System.Collections.Generic; using Amazon.DynamoDBv2; using Amazon.DynamoDBv2.Model; using Amazon.Runtime; namespace com.amazonaws.codesamples { class LowLevelBatchGet { private static string table1Name = "Forum"; private static string table2Name = "Thread"; private static AmazonDynamoDBClient client = new AmazonDynamoDBClient(); static void Main(string[] args) { try { RetrieveMultipleItemsBatchGet(); Console.WriteLine("To continue, press Enter"); Console.ReadLine(); } catch (AmazonServiceException e) { Console.WriteLine(e.Message); } catch (Exception e) { Console.WriteLine(e.Message); } } private static void RetrieveMultipleItemsBatchGet() { var request = new BatchGetItemRequest { RequestItems = new Dictionary() { { table1Name, new KeysAndAttributes { Keys = new List >() { new Dictionary() { { "Name", new AttributeValue { S = "Amazon DynamoDB" } } }, new Dictionary() { { "Name", new AttributeValue { S = "Amazon S3" } } } } }}, { table2Name, new KeysAndAttributes { Keys = new List >() { new Dictionary() { { "ForumName", new AttributeValue { S = "Amazon DynamoDB" } }, { "Subject", new AttributeValue { S = "DynamoDB Thread 1" } } }, new Dictionary() { { "ForumName", new AttributeValue { S = "Amazon DynamoDB" } }, { "Subject", new AttributeValue { S = "DynamoDB Thread 2" } } }, new Dictionary() { { "ForumName", new AttributeValue { S = "Amazon S3" } }, { "Subject", new AttributeValue { S = "S3 Thread 1" } } } } } } } }; BatchGetItemResponse response; do { Console.WriteLine("Making request"); response = client.BatchGetItem(request); // Check the response. var responses = response.Responses; // Attribute list in the response. foreach (var tableResponse in responses) { var tableResults = tableResponse.Value; Console.WriteLine("Items retrieved from table {0}", tableResponse.Key); foreach (var item1 in tableResults) { PrintItem(item1); } } // Any unprocessed keys? could happen if you exceed ProvisionedThroughput or some other error. Dictionary unprocessedKeys = response.UnprocessedKeys; foreach (var unprocessedTableKeys in unprocessedKeys) { // Print table name. Console.WriteLine(unprocessedTableKeys.Key); // Print unprocessed primary keys. foreach (var key in unprocessedTableKeys.Value.Keys) { PrintItem(key); } } request.RequestItems = unprocessedKeys; } while (response.UnprocessedKeys.Count > 0); } private static void PrintItem(Dictionary attributeList) { foreach (KeyValuePair kvp in attributeList) { string attributeName = kvp.Key; AttributeValue value = kvp.Value; Console.WriteLine( attributeName + " " + (value.S == null ? "" : "S=[" + value.S + "]") + (value.N == null ? "" : "N=[" + value.N + "]") + (value.SS == null ? "" : "SS=[" + string.Join(",", value.SS.ToArray()) + "]") + (value.NS == null ? "" : "NS=[" + string.Join(",", value.NS.ToArray()) + "]") ); } Console.WriteLine("************************************************"); } } } ``` # Example: Handling binary type attributes using the Amazon SDK for .NET low-level API Example: Handling binary type attributes - .NET low-level API The following C\$1 code example illustrates the handling of binary type attributes. The example adds an item to the `Reply` table. The item includes a binary type attribute (`ExtendedMessage`) that stores compressed data. The example then retrieves the item and prints all the attribute values. For illustration, the example uses the `GZipStream` class to compress a sample stream and assigns it to the `ExtendedMessage` attribute, and decompresses it when printing the attribute value. For step-by-step instructions for testing the following example, see [.NET code examples](CodeSamples.DotNet.md). **Example** ``` using System; using System.Collections.Generic; using System.IO; using System.IO.Compression; using Amazon.DynamoDBv2; using Amazon.DynamoDBv2.Model; using Amazon.Runtime; namespace com.amazonaws.codesamples { class LowLevelItemBinaryExample { private static string tableName = "Reply"; private static AmazonDynamoDBClient client = new AmazonDynamoDBClient(); static void Main(string[] args) { // Reply table primary key. string replyIdPartitionKey = "Amazon DynamoDB#DynamoDB Thread 1"; string replyDateTimeSortKey = Convert.ToString(DateTime.UtcNow); try { CreateItem(replyIdPartitionKey, replyDateTimeSortKey); RetrieveItem(replyIdPartitionKey, replyDateTimeSortKey); // Delete item. DeleteItem(replyIdPartitionKey, replyDateTimeSortKey); 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); } } private static void CreateItem(string partitionKey, string sortKey) { MemoryStream compressedMessage = ToGzipMemoryStream("Some long extended message to compress."); var request = new PutItemRequest { TableName = tableName, Item = new Dictionary() { { "Id", new AttributeValue { S = partitionKey }}, { "ReplyDateTime", new AttributeValue { S = sortKey }}, { "Subject", new AttributeValue { S = "Binary type " }}, { "Message", new AttributeValue { S = "Some message about the binary type" }}, { "ExtendedMessage", new AttributeValue { B = compressedMessage }} } }; client.PutItem(request); } private static void RetrieveItem(string partitionKey, string sortKey) { var request = new GetItemRequest { TableName = tableName, Key = new Dictionary() { { "Id", new AttributeValue { S = partitionKey } }, { "ReplyDateTime", new AttributeValue { S = sortKey } } }, ConsistentRead = true }; var response = client.GetItem(request); // Check the response. var attributeList = response.Item; // attribute list in the response. Console.WriteLine("\nPrinting item after retrieving it ............"); PrintItem(attributeList); } private static void DeleteItem(string partitionKey, string sortKey) { var request = new DeleteItemRequest { TableName = tableName, Key = new Dictionary() { { "Id", new AttributeValue { S = partitionKey } }, { "ReplyDateTime", new AttributeValue { S = sortKey } } } }; var response = client.DeleteItem(request); } private static void PrintItem(Dictionary attributeList) { foreach (KeyValuePair kvp in attributeList) { string attributeName = kvp.Key; AttributeValue value = kvp.Value; Console.WriteLine( attributeName + " " + (value.S == null ? "" : "S=[" + value.S + "]") + (value.N == null ? "" : "N=[" + value.N + "]") + (value.SS == null ? "" : "SS=[" + string.Join(",", value.SS.ToArray()) + "]") + (value.NS == null ? "" : "NS=[" + string.Join(",", value.NS.ToArray()) + "]") + (value.B == null ? "" : "B=[" + FromGzipMemoryStream(value.B) + "]") ); } Console.WriteLine("************************************************"); } private static MemoryStream ToGzipMemoryStream(string value) { MemoryStream output = new MemoryStream(); using (GZipStream zipStream = new GZipStream(output, CompressionMode.Compress, true)) using (StreamWriter writer = new StreamWriter(zipStream)) { writer.Write(value); } return output; } private static string FromGzipMemoryStream(MemoryStream stream) { using (GZipStream zipStream = new GZipStream(stream, CompressionMode.Decompress)) using (StreamReader reader = new StreamReader(zipStream)) { return reader.ReadToEnd(); } } } } ```