El SDK AWS móvil para Xamarin ahora está incluido en. AWS SDK para .NET Esta guía hace referencia a la versión archivada del SDK para móviles para Xamarin.
Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Amazon DynamoDB
## ¿Qué es Amazon DynamoDB?
[Amazon DynamoDB](https://aws.amazon.com/dynamodb/) es un servicio de bases de datos no relacionales rápido y con un alto grado de escalabilidad. DynamoDB elimina las limitaciones tradicionales de escalabilidad del almacenamiento de datos y, al mismo tiempo, mantiene una baja latencia y un desempeño previsible.
## Conceptos clave
El modelo de datos de DynamoDB incluye conceptos como las tablas, los elementos y los atributos.
### Tablas
En Amazon DynamoDB, una base de datos es una colección de tablas. Una tabla es una colección de elementos y cada elemento es una colección de atributos.
En una base de datos relacional, una tabla tiene un esquema predefinido como, por ejemplo, el nombre de la tabla, la clave principal, la lista de los nombres de columnas y los tipos de datos de estas. Todos los registros almacenados en la tabla deben tener el mismo conjunto de columnas. En cambio, DynamoDB solo requiere que una tabla tenga una clave principal, pero no es necesario que se definan todos los nombres de atributos y los tipos de datos de antemano.
Para obtener más información acerca del procedimiento para trabajar con tablas, consulte [Uso de tablas en DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.html).
### Elementos y atributos
Cada elemento de una tabla de DynamoDB puede tener cualquier número de atributos, aunque existe un límite de 400 KB para el tamaño del elemento. El tamaño de un elemento es la suma de las longitudes de los nombres y los valores de sus atributos (longitudes binarias y UTF-8).
Cada atributo de un elemento es un par nombre-valor. Un atributo puede tener un valor único o un conjunto de varios valores (atributo multivalor). Por ejemplo, un elemento de libro puede tener atributos de título y autores. Cada libro tiene un título, pero puede tener muchos autores. El atributo multivalor es un conjunto. No se admiten los valores duplicados.
Por ejemplo, imagine que desea almacenar un catálogo de productos en DynamoDB. Puede crear una tabla ProductCatalog, con el atributo Id como clave principal. La clave principal identifica de forma única a cada elemento, de forma que en la tabla no puede haber dos productos con el mismo ID.
Para obtener más información acerca del trabajo con elementos, consulte [Uso de elementos en DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html).
### Data Types
Amazon DynamoDB admite los siguientes tipos de datos:
+ **Tipos escalares**: número, cadena, binario, booleano y nulo.
+ **Tipos multivalor**: conjunto de cadenas, conjunto de números y conjunto binario.
+ **Tipos de documentos**: lista y mapa.
Para obtener más información acerca de los tipos de datos escalares, los tipos de datos multivalor y los tipos de datos de documentos, consulte [Tipos de datos de DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataModel.html#DataModel.DataTypes).
### Clave principal
Al crear una tabla, además de asignarle un nombre, debe especificar su clave principal. La clave principal identifica de forma única a cada elemento de la tabla, de manera que no puede haber dos elementos con la misma clave. DynamoDB admite los dos tipos siguientes de claves principales:
+ **Clave hash**: la clave principal se compone de un atributo hash. DynamoDB genera un índice hash desordenado basado en este atributo de la clave principal. Cada elemento de la tabla se identifica de forma única por medio de su valor de clave hash.
+ **Clave hash y de rango**: la clave principal se compone de dos atributos. El primer atributo es el atributo hash y el segundo es el atributo de rango. DynamoDB crea un índice hash sin ordenar basado en el atributo hash de la clave principal y un índice de rango ordenado basado en el atributo de rango de la clave principal. Cada elemento de la tabla se identifica de forma única por medio de la combinación de sus valores de clave hash y de rango. Dos elementos pueden tener el mismo valor de clave hash, pero deben tener diferentes valores de clave de rango.
### Índices secundarios
Cuando cree una tabla con una clave hash y de rango, puede definir uno o varios índices secundarios en dicha tabla. Un índice secundario le permite consultar los datos de la tabla usando una clave alternativa, además de realizar consultas basadas en la clave principal.
DynamoDB admite dos tipos de índices secundarios: los índices secundarios locales y los índices secundarios globales.
+ **Índice secundario local**: un índice que tiene la misma clave hash que la tabla, pero una clave de rango diferente.
+ **Índice secundario global**: un índice con una clave hash y de rango que puede diferir de las claves de la tabla.
Puede definir un máximo de 5 índices secundarios globales y 5 índices secundarios locales por cada tabla. Para obtener más información, consulte [Uso de índices secundarios para mejorar el acceso a los datos en DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/SecondaryIndexes.html) en la Guía para desarrolladores de DynamoDB.
### Consulta y examen
Además de utilizar las claves principales para acceder a los elementos, Amazon DynamoDB también proporciona APIs dos para buscar los datos: Query y Scan. Es recomendable que lea [Guidelines for Query and Scan](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScanGuidelines.html) en la Guía para desarrolladores de DynamoDB para familiarizarse con algunas prácticas recomendadas.
#### Consultar
Una operación de consulta (Query) encuentra los elementos de una tabla o un índice secundario usando únicamente los valores de los atributos de la clave principal. Debe proporcionar un nombre de atributo de clave hash y un valor para la búsqueda. Si lo desea, puede proporcionar un nombre y un valor de atributo de clave de rango y utilizar un operador de comparación para limitar los resultados de búsqueda.
Para ver las consultas de muestra, lea:
+ [Uso del modelo de documento](dynamodb-integration-docmodel.md)
+ [Uso del modelo de persistencia de objetos](dynamodb-integration-objectpersistencemodel.md)
+ [Uso del nivel de servicio de DynamoDB APIs](dynamodb-integration-lowlevelapi.md)
Para obtener más información acerca de las consultas, vea [Consulta](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScan.html#QueryAndScan.Query) en la Guía para desarrolladores de DynamoDB.
#### Examen
Una operación de examen (Scan) lee todos los elementos de una tabla o de un índice secundario. De manera predeterminada, una operación de examen devuelve todos los atributos de datos de todos los elementos de la tabla o el índice. Puede usar el ProjectionExpression parámetro para que Scan solo devuelva algunos de los atributos, en lugar de todos ellos.
Para ver los exámenes de muestra, lea:
+ [Uso del modelo de documento](dynamodb-integration-docmodel.md)
+ [Uso del modelo de persistencia de objetos](dynamodb-integration-objectpersistencemodel.md)
+ [Uso del nivel de servicio de DynamoDB APIs](dynamodb-integration-lowlevelapi.md)
Para obtener más información acerca de las operaciones de análisis, consulte [Análisis](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScan.html#QueryAndScan.Scan) en la Guía para desarrolladores de DynamoDB.
## Configuración del proyecto
### Requisitos previos
Para utilizar DynamoDB en su aplicación, tendrá que añadir el SDK al proyecto. Para ello, siga las instrucciones que se describen en [Setting Up the AWS Mobile SDK for .NET and Xamarin](setup.md).
### Creación de una tabla de DynamoDB
Para crear una tabla, vaya a la [consola de DynamoDB](https://console.aws.amazon.com/dynamodb/home) y siga estos pasos:
1. Haga clic en **Create Table (Crear tabla)**.
1. Escriba el nombre de la tabla.
1. Seleccione **Hash (Hash)** como tipo de clave principal.
1. Seleccione un tipo y escriba un valor para el nombre del atributo hash. Haga clic en **Continue (Continuar)**.
1. En la página **Add Indexes (Añadir índices)**, si tiene previsto usar índices secundarios globales, defina **Index Type (Tipo de índice)** como "Global Secondary Index" y en **Index Hash Key (Clave hash de índice)**, escriba un valor para el índice secundario. Esto le permitirá realizar consultas y exámenes usando el índice principal y el índice secundario. Haga clic en **Add Index To Table (Añadir índice a tabla)** y, a continuación, haga clic en **Continue (Continuar)**. Para omitir la utilización de los índices secundarios globales, haga clic en **Continue (Continuar)**.
1. Establezca la capacidad de lectura y escritura en los niveles deseados. Para obtener más información acerca de la configuración de la capacidad, consulte [Provisioned Throughput in Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ProvisionedThroughputIntro.html). Haga clic en **Continue (Continuar)**.
1. En la siguiente pantalla, escriba un correo electrónico de notificación para crear alarmas de rendimiento si lo desea. Haga clic en **Continue (Continuar)**.
1. En la página de resumen, haga clic en **Create (Crear)**. DynamoDB creará la base de datos.
### Definición de permisos para DynamoDB
Para utilizar DynamoDB en una aplicación, debe definir los permisos correctos. La siguiente política de IAM permite al usuario eliminar, obtener, colocar, consultar, examinar y actualizar elementos en una tabla de DynamoDB, que se identifica mediante un [ARN](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html):
```
{
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:DeleteItem",
"dynamodb:GetItem",
"dynamodb:PutItem",
"dynamodb:Query",
"dynamodb:Scan",
"dynamodb:UpdateItem"
],
"Resource": "arn:aws:dynamodb:us-west-2:123456789012:table/MyTable"
}
]
}
```
Puede modificar las políticas en la [consola de IAM](https://console.aws.amazon.com/iam/). Debe añadir o eliminar acciones permitidas en función de las necesidades de su aplicación.
Para obtener más información acerca de las políticas de IAM, consulte [cómo usar IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/IAM_Introduction.html).
Para obtener más información acerca de las políticas específicas de DynamoDB, consulte [Cómo usar IAM para controlar el acceso a los recursos de DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/UsingIAMWithDDB.html) en la Guía para desarrolladores de DynamoDB.
## Integración de DynamoDB en una aplicación
AWS Mobile SDK para .NET y Xamarin proporciona una biblioteca de alto nivel para trabajar con DynamoDB. También se pueden realizar solicitudes directamente en la API de DynamoDB de bajo nivel, pero para la mayoría de los casos de uso se recomienda trabajar con la biblioteca de alto nivel. AmazonDynamoDBClient Es una parte especialmente útil de la biblioteca de alto nivel. Con esta clase, puede realizar varias operaciones de creación, lectura, actualización y eliminación (CRUD, Create, Read, Update and Delete) y ejecutar consultas.
El AWS Mobile SDK para.NET y Xamarin le permiten realizar llamadas desde el AWS SDK para que .NET funcione APIs con DynamoDB. Todos APIs están disponibles en la .dll. AWSSDK Para obtener información acerca de la descarga de AWS SDK para .NET, consulte [AWS SDK para .NET](https://aws.amazon.com/sdk-for-net/).
Existen tres formas de interactuar con DynamoDB en una aplicación de Xamarin:
+ **Modelo de documentos**: esta API proporciona clases contenedoras basadas en la API de bajo nivel de DynamoDB para simplificar las tareas de programación. Table y Document son las clases contenedoras principales. Puede utilizar el modelo de documentos para operaciones de datos como, por ejemplo, crear, recuperar, actualizar y eliminar elementos. La API está disponible en Amazon.DynamoDB. DocumentModel espacio de nombres.
+ **Modelo de persistencia de objetos**: la API de persistencia de objetos permite asignar las clases del lado del cliente a las tablas de DynamoDB. A continuación, cada instancia de objeto se mapea a un elemento en las tablas correspondientes. La DBContext clase Dynamo de esta API proporciona métodos para guardar los objetos del lado del cliente en una tabla, recuperar elementos como objetos y realizar consultas y escaneos. Puede utilizar el modelo de persistencia de objetos para operaciones de datos como, por ejemplo, crear, recuperar, actualizar y eliminar elementos. En primer lugar, debe crear sus tablas con la API de cliente de servicio y, a continuación, utilizar el modelo de persistencia de objetos para asignar las clases a las tablas. La API está disponible en Amazon.DynamoDB. DataModel espacio de nombres.
+ **API de cliente de servicio**: esta es la API de nivel de protocolo que más se ajusta a la API de DynamoDB. Puede utilizar esta API de bajo nivel para todas las operaciones de tablas y elementos como, por ejemplo, crear, actualizar y eliminar tablas y elementos. También puede consultar y examinar sus tablas. Esta API está disponible en el espacio de nombres Amazon.DynamoDB.
Estos tres modelos se exploran de manera detallada en los siguientes temas:
**Topics**
# Uso del modelo de documento
El modelo de documento proporciona clases de encapsulamiento para la API .NET de bajo nivel. Table y Document son las clases contenedoras principales. Puede utilizar el modelo de documento para crear, recuperar, actualizar y eliminar elementos. Para crear, actualizar y eliminar las tablas, debe utilizar la API de bajo nivel. Para obtener instrucciones sobre cómo usar la API de bajo nivel, consulte [Uso del nivel de servicio de DynamoDB](dynamodb-integration-lowlevelapi.md). APIs La API de bajo nivel está disponible en Amazon.DynamoDB. DocumentModel espacio de nombres.
Para obtener más información sobre el modelo de documento, consulte [Modelo de documento de .NET](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DotNetSDKMidLevel.html).
## Creación de un cliente de DynamoDB
Para crear un cliente de DynamoDB:
```
var client = new AmazonDynamoDBClient(credentials,region);
DynamoDBContext context = new DynamoDBContext(client);
```
## Operaciones de CRUD
### Almacenamiento de un elemento
Crear un elemento:
```
Table table = Table.LoadTable(client, "Books");
id = Guid.NewGuid().ToString();
var books = new Document();
books["Id"] = id;
books["Author"] = "Mark Twain";
books["Title"] = "Adventures of Huckleberry Finn";
books["ISBN"] = "112-111111";
books["Price"] = "10";
```
Guardar un elemento en una tabla de DynamoDB:
```
var book = await table.PutItemAsync(books);
```
### Recuperación de un elemento
Para recuperar un elemento:
```
public async Task GetItemAsync(AWSCredentials credentials, RegionEndpoint region)
{
var client = new AmazonDynamoDBClient(credentials, region);
Table books = Table.LoadTable(client, "Books");
var book = await books.GetItemAsync(id);
}
```
### Actualización de un elemento
Para actualizar un elemento:
```
public async Task UpdateItemAttributesAsync(AWSCredentials credentials, RegionEndpoint region)
{
var book = new Document();
book["Id"] = id;
book["PageCount"] = "200";
var client = new AmazonDynamoDBClient(credentials, region);
Table books = Table.LoadTable(client, "Books");
Document updatedBook = await books.UpdateItemAsync(book);
}
```
Para actualizar un elemento condicionalmente:
```
public async Task UpdateItemConditionallyAsync(AWSCredentials credentials, RegionEndpoint region) {
var book = new Document();
book["Id"] = id;
book["Price"] = "30";
// For conditional price update, creating a condition expression.
Expression expr = new Expression();
expr.ExpressionStatement = "Price = :val";
expr.ExpressionAttributeValues[":val"] = 10.00;
var client = new AmazonDynamoDBClient(credentials, region);
Table books = Table.LoadTable(client, "Books");
Document updatedBook = await books.UpdateItemAsync(book);
}
```
### Eliminación de un elemento
Para eliminar un elemento:
```
public async Task DeleteItemAsync(AWSCredentials credentials, RegionEndpoint region)
{
var client = new AmazonDynamoDBClient(credentials, region);
Table books = Table.LoadTable(client, "Books");
await books.DeleteItemAsync(id);
}
```
### Consulta y examen
Para consultar y recuperar todos los libros cuyo autor sea "Mark Twain":
```
public async Task QueryAsync(AWSCredentials credentials, RegionEndpoint region) {
var client = new AmazonDynamoDBClient(credentials, region);
Table books = Table.LoadTable(client, "Books");
var search = books.Query(new QueryOperationConfig() {
IndexName = "Author-Title-index",
Filter = new QueryFilter("Author", QueryOperator.Equal, "Mark Twain")
});
Console.WriteLine("ScanAsync: printing query response");
var documents = await search.GetRemainingAsync();
documents.ForEach((d) = > {
PrintDocument(d);
});
}
```
El código de ejemplo de examen que se muestra a continuación devuelve todos los libros de la tabla:
```
public async Task ScanAsync(AWSCredentials credentials, RegionEndpoint region) {
var client = new AmazonDynamoDBClient(credentials, region);
Table books = Table.LoadTable(client, "Books");
var search = books.Scan(new ScanOperationConfig() {
ConsistentRead = true
});
Console.WriteLine("ScanAsync: printing scan response");
var documents = await search.GetRemainingAsync();
documents.ForEach((d) = > {
PrintDocument(d);
});
}
```
# Uso del modelo de persistencia de objetos
AWS Mobile SDK para .NET y Xamarin proporciona un modelo de persistencia de objetos que le permite mapear las clases en el cliente a una tabla de DynamoDB. A continuación, cada instancia de objeto se mapea a un elemento de la tabla correspondiente. Para guardar los objetos del lado del cliente en una tabla, el modelo Object Persistence proporciona la DBContext clase Dynamo, un punto de entrada a DynamoDB. Esta categoría le ofrece una conexión a DynamoDB y le permite obtener acceso a tablas, realizar diversas operaciones CRUD y ejecutar consultas.
El modelo de persistencia de objetos no proporciona una API para crear, actualizar o eliminar tablas. Solo ofrece operaciones de datos. Para crear, actualizar y eliminar las tablas, debe utilizar la API de bajo nivel. Para obtener instrucciones sobre cómo usar la API de bajo nivel, consulte [Uso del nivel de servicio de DynamoDB](dynamodb-integration-lowlevelapi.md). APIs
## Descripción general de
El modelo de persistencia de objetos proporciona un conjunto de atributos para asignar las clases del lado del cliente a las tablas y a los atributos de las tablas. properties/fields El modelo de persistencia de objetos admite el mapeo explícito y predeterminado entre las propiedades de clase y los atributos de tabla.
+ **Mapeo explícito**: para asignar una propiedad a una clave principal, debe utilizar los atributos del modelo Dynamo Key Object Persistence y Dynamo DBHash DBRange Key Object Persistence. Además, en el caso de los atributos clave no principales, si el nombre de una propiedad de su clase y el atributo de tabla correspondiente al que desea asignarlo no son iguales, debe definir la asignación añadiendo explícitamente el atributo Dynamo. DBProperty
+ **Mapeo predeterminado**: de forma predeterminada, el modelo de persistencia de objetos mapea las propiedades de clase a los atributos con el mismo nombre de la tabla.
No tiene que mapear cada propiedad de clase. Para identificar estas propiedades, añada el atributo DBIgnore Dynamo. Al guardar y recuperar una instancia de un objeto se podría omitir cualquier propiedad marcada con este atributo.
## Tipos de datos admitidos
El modelo de persistencia de objetos admite un conjunto de tipos de datos, colecciones y tipos de datos arbitrarios de .NET primitivos. El modelo admite los siguientes tipos de datos primitivos.
+ bool
+ byte
+ char
+ DateTime
+ decimal, double, float
+ Int16, Int32, Int64
+ SByte
+ cadena
+ UInt16, UInt32, UInt64
El modelo de persistencia de objetos también admite los tipos de colecciones .NET con las limitaciones siguientes:
+ El tipo de colección debe implementar ICollection una interfaz.
+ El tipo de colección se debe componer de los tipos de primitivas admitidos. Por ejemplo, ICollection, ICollection.
+ El tipo de colección debe proporcionar un constructor sin parámetros.
Para obtener más información sobre el modelo de persistencia de objetos, consulte [Modelo de persistencia de objetos de .NET](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DotNetSDKHighLevel.html).
## Creación de un cliente de DynamoDB
Para crear un cliente de DynamoDB:
```
var client = new AmazonDynamoDBClient(credentials,region);
DynamoDBContext context = new DynamoDBContext(client);
```
## Operaciones de CRUD
### Guardar un objeto
Crear un objeto:
```
[DynamoDBTable("Books")]
public class Book {
[DynamoDBHashKey] // Hash key.
public string Id {
get;
set;
}
[DynamoDBGlobalSecondaryIndexHashKey]
public string Author {
get;
set;
}
[DynamoDBGlobalSecondaryIndexRangeKey]
public string Title {
get;
set;
}
public string ISBN {
get;
set;
}
public int Price {
get;
set;
}
public string PageCount {
get;
set;
}
}
Book myBook = new Book
{
Id = id,
Author = "Charles Dickens",
Title = "Oliver Twist",
ISBN = "111-1111111001",
Price = 10,
PageCount = 300
};
```
Guardar un objeto en una tabla de DynamoDB:
```
context.Save(myBook);
```
### Recuperar un objeto
Para recuperar un objeto:
```
Book retrievedBook = context.Load(1);
```
### Actualizar un objeto
Para actualizar un objeto:
```
Book retrievedBook = context.Load(1);
retrievedBook.ISBN = "111-1111111001";
context.Save(retrievedBook);
```
### Eliminar un objeto
Para eliminar un objeto:
```
Book retrievedBook = context.Load(1);
context.Delete(retrievedBook);
```
## Consulta y examen
Para consultar y recuperar todos los libros cuyo autor sea "Charles Dickens":
```
public async Task QueryAsync(AWSCredentials credentials, RegionEndpoint region) {
var client = new AmazonDynamoDBClient(credentials, region);
DynamoDBContext context = new DynamoDBContext(client);
var search = context.FromQueryAsync < Book > (new Amazon.DynamoDBv2.DocumentModel.QueryOperationConfig() {
IndexName = "Author-Title-index",
Filter = new Amazon.DynamoDBv2.DocumentModel.QueryFilter("Author", Amazon.DynamoDBv2.DocumentModel.QueryOperator.Equal, "Charles Dickens")
});
Console.WriteLine("items retrieved");
var searchResponse = await search.GetRemainingAsync();
searchResponse.ForEach((s) = > {
Console.WriteLine(s.ToString());
});
}
```
El código de ejemplo de examen que se muestra a continuación devuelve todos los libros de la tabla:
```
public async Task ScanAsync(AWSCredentials credentials, RegionEndpoint region) {
var client = new AmazonDynamoDBClient(credentials, region);
DynamoDBContext context = new DynamoDBContext(client);
var search = context.FromScanAsync < Book > (new Amazon.DynamoDBv2.DocumentModel.ScanOperationConfig() {
ConsistentRead = true
});
Console.WriteLine("items retrieved");
var searchResponse = await search.GetRemainingAsync();
searchResponse.ForEach((s) = > {
Console.WriteLine(s.ToString());
});
}
```
# Uso del nivel de servicio de DynamoDB APIs
El nivel de servicio de Dynamo APIs le permite crear, actualizar y eliminar tablas. También puede realizar operaciones típicas de creación, lectura, actualización y eliminación (CRUD, Create, Read, Update and Delete) en los elementos de una tabla usando esta API.
## Creación de un cliente de DynamoDB
Para crear un cliente de DynamoDB:
```
AmazonDynamoDBClient client = new AmazonDynamoDBClient(credentials,region);
```
## Operaciones de CRUD
### Almacenamiento de un elemento
Para guardar un elemento en una tabla de DynamoDB:
```
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient(credentials,region);
// Define item attributes
Dictionary attributes = new Dictionary();
// Author is hash-key
attributes["Author"] = new AttributeValue { S = "Mark Twain" };
attributes["Title"] = new AttributeValue { S = "The Adventures of Tom Sawyer" };
attributes["PageCount"] = new AttributeValue { N = "275" };
attributes["Price"] = new AttributeValue{N = "10.00"};
attributes["Id"] = new AttributeValue{N="10"};
attributes["ISBN"] = new AttributeValue{S="111-1111111"};
// Create PutItem request
PutItemRequest request = new PutItemRequest
{
TableName = "Books",
Item = attributes
};
// Issue PutItem request
var response = await client.PutItemAsync(request);
```
### Recuperación de un elemento
Para recuperar un elemento:
```
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient(credentials,region);
Dictionary key = new Dictionary
{
{ "Id", new AttributeValue { N = "10" } }
};
// Create GetItem request
GetItemRequest request = new GetItemRequest
{
TableName = "Books",
Key = key,
};
// Issue request
var result = await client.GetItemAsync(request);
// View response
Console.WriteLine("Item:");
Dictionary item = result.Item;
foreach (var keyValuePair in item)
{
Console.WriteLine("Author := {0}", item["Author"]);
Console.WriteLine("Title := {0}", item["Title"]);
Console.WriteLine("Price:= {0}", item["Price"]);
Console.WriteLine("PageCount := {0}", item["PageCount"]);
}
```
### Actualización de un elemento
Para actualizar un elemento:
```
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient(credentials,region);
Dictionary key = new Dictionary
{
{ "Id", new AttributeValue { N = "10" } }
};
// Define attribute updates
Dictionary updates = new Dictionary();
// Add a new string to the item's Genres SS attribute
updates["Genres"] = new AttributeValueUpdate()
{
Action = AttributeAction.ADD,
Value = new AttributeValue { SS = new List { "Bildungsroman" } }
};
// Create UpdateItem request
UpdateItemRequest request = new UpdateItemRequest
{
TableName = "Books",
Key = key,
AttributeUpdates = updates
};
// Issue request
var response = await client.UpdateItemAsync(request);
```
### Eliminación de un elemento
Para eliminar un elemento:
```
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient(credentials,region);
Dictionary key = new Dictionary
{
{ "Id", new AttributeValue { N = "10" } }
};
// Create DeleteItem request
DeleteItemRequest request = new DeleteItemRequest
{
TableName = "Books",
Key = key
};
// Issue request
var response = await client.DeleteItemAsync(request);
```
## Consulta y examen
Para consultar y recuperar todos los libros cuyo autor sea "Mark Twain":
```
public void Query(AWSCredentials credentials, RegionEndpoint region) {
using(var client = new AmazonDynamoDBClient(credentials, region)) {
var queryResponse = await client.QueryAsync(new QueryRequest() {
TableName = "Books",
IndexName = "Author-Title-index",
KeyConditionExpression = "Author = :v_Id",
ExpressionAttributeValues = new Dictionary < string, AttributeValue > {
{
":v_Id", new AttributeValue {
S = "Mark Twain"
}
}
}
});
queryResponse.Items.ForEach((i) = > {
Console.WriteLine(i["Title"].S);
});
}
}
```
El código de ejemplo de examen que se muestra a continuación devuelve todos los libros de la tabla:
```
public void Scan(AWSCredentials credentials, RegionEndpoint region) {
using(var client = new AmazonDynamoDBClient(credentials, region)) {
var queryResponse = client.Scan(new ScanRequest() {
TableName = "Books"
});
queryResponse.Items.ForEach((i) = > {
Console.WriteLine(i["Title"].S);
});
}
}
```