Release: AWS SDK for .NET 1.4.0

This release add support for Amazon DynamoDB. Amazon DynamoDB is a fully managed NoSQL database service that provides fast and predictable performance with seamless scalability. Customers can easily launch a new Amazon DynamoDB database table, scale up or down their request capacity for the table without downtime or performance degradation, and gain visibility into resource utilization and performance metrics. Amazon DynamoDB enables customers to offload the administrative burdens of operating and scaling distributed databases to AWS, so they don.t have to worry about hardware provisioning, setup and configuration, replication, software patching, or cluster scaling.

Amazon DynamoDB is designed to address the core problems of database management, performance, scalability, and reliability. Developers can create a database table that can store and retrieve any amount of data, and serve any level of request traffic. DynamoDB automatically spreads the data and traffic for the table over a sufficient number of servers to handle the request capacity specified by the customer and the amount of data stored, while maintaining consistent, fast performance. All data items are stored on Solid State Disks (SSDs) and are automatically replicated across multiple Availability Zones in a Region to provide built-in high availability and data durability.

In addition to basic service API, the AWS SDK for .NET includes two helper namespaces and corresponding classes for using Amazon DynamoDB:

• Amazon.DynamoDB.DocumentModel provides helper classes to simplify working with tables and data. The key structures are the Table and Document classes.
• Amazon.DynamoDB.DataModel provides an object persistence framework for mapping client-side classes to Amazon DynamoDB data. The key structures are the DynamoDBContext class and a number of Attributes that are used to mark up client classes.

Before using any of the Amazon DynamoDB APIs, you need to create a client. The sample below shows multiple options in constructing an instance of AmazonDynamoDBClient.

    AmazonDynamoDBClient client;
    client = new AmazonDynamoDBClient(); // Constructs AmazonDynamoDBClient with the credentials defined in the App.config.
    client = new AmazonDynamoDBClient("accessKey", "secretKey");
                    

The code below shows how a table can be created, populated and scanned, using the base Amazon DynamoDB API.

    // Create table "SampleMovies"
    CreateTableRequest createTableRequest = new CreateTableRequest
    {
        TableName = "SampleMovies",
        ProvisionedThroughput = new ProvisionedThroughput { ReadCapacityUnits = 10, WriteCapacityUnits = 10 },
        KeySchema = new KeySchema { HashKeyElement = new KeySchemaElement { AttributeType = "S", AttributeName = "Name" } }
    };
    Console.WriteLine("Table status: " + client.CreateTable(createTableRequest).CreateTableResult.TableDescription.TableStatus);

    // Wait a few moments for the new table to become active...

    // Put new item
    PutItemRequest putItemRequest = new PutItemRequest
    {
        TableName = "SampleMovies",
        Item = new Dictionary
        {
            { "Name", new AttributeValue { S = "Bill & Ted's Excellent Adventure" } },
            { "Year", new AttributeValue { N = "1989"} },
            { "Actors", new AttributeValue { SS = new List { "Keanu Reeves", "Alex Winter", "George Carlin" } } }
        }
    };
    Console.WriteLine("Consumed capacity: " + client.PutItem(putItemRequest).PutItemResult.ConsumedCapacityUnits);

    // Scan for movies with a year attribute greater than 1985
    ScanRequest scanRequest = new ScanRequest
    {
        TableName = "SampleMovies",
        ScanFilter = new Dictionary
        {
            { "Year", new Condition
                {
                    ComparisonOperator = "GT",
                    AttributeValueList = new List { new AttributeValue { N = "1985" } }
                }
            }
        }
    };
    Console.WriteLine("Items found: " + client.Scan(scanRequest).ScanResult.Items.Count);
                    

The following code sample shows how the Document and Table helper classes can be used to achieve a similar result.

    // Load table
    Table table = Table.LoadTable(client, "SampleMovies");

    // Create and save document
    Document doc = new Document();
    doc["Name"] = "The Lion King";
    doc["Year"] = 1994;
    doc["Actors"] = new List
    {
        "Jonathan Taylor Thomas", "Matthew Broderick", "James Earl Jones", "Jeremy Irons"
    };
    table.PutItem(doc);

    // Scan table for movies with "Jeremy Irons"
    ScanFilter filter = new ScanFilter();
    filter.AddCondition("Actors", ScanOperator.Contains, "Jeremy Irons");
    Search searchResults = table.Scan(filter);
    List items = searchResults.GetRemaining();
    Console.WriteLine("Items: " + items.Count);
    		

Alternatively, you can use the Amazon.DynamoDB.DataModel namespace and associate structures to mark up a class and accomplish similar results.

The following code sample shows an annotated class.

    [DynamoDBTable("SampleMovies")]
    public class SampleMovie
    {
        [DynamoDBHashKey]
        public string Name { get; set; }

        public int Year { get; set; }
        public List Actors { get; set; }
    }
                    

The following code sample shows how this class can be stored in Amazon DynamoDB.

    // Create DynamoDBContext
    DynamoDBContext context = new DynamoDBContext(client);

    // Create and save movie
    SampleMovie movie = new SampleMovie
    {
        Name = "The English Patient",
        Year = 1996,
        Actors = new List { "Ralph Fiennes", "Juliette Binoche", "Willem Dafoe" }
    };
    context.Save(movie);

    // Scan for movies made before 2000 with "English" in the title
    IEnumerable items = context.Scan(
        new ScanCondition("Name", ScanOperator.Contains, "English"),
        new ScanCondition("Year", ScanOperator.LessThan, 2000));
    Console.WriteLine("Items: " + items.Count());
    Console.WriteLine("Items: " + items.Count());
                    

The ActionIdentifier constants found in the Amazon.Auth.AccessControlPolicy.ActionIdentifiers namespace have been updated to contain the latest constants used for creating policies and match the names found in AWS documentation as well as the AWS Policy Generator.

CloudFormationActionIdentifers and CloudFrontActionIdentifers where renamed to CloudFormationActionIdentifiers and CloudFrontActionIdentifiers.

AllSqsActions was renamed to AllSQSActions

The following S3 action constants were renamed to match the S3 documentation.

Amazon SNS Delivery Policies give you options to control the delivery rate and error handling for each SNS endpoint. You can, for example, use a Delivery Policy to avoid overwhelming a particular endpoint with a sudden barrage of messages. Delivery Policies can be set for Topics and for the endpoints associated with a particular Topic. Each Delivery Policy contains a Retry Policy and a Throttle Policy. With this release, the policies are effective for the HTTP and HTTPS Subscription types.

The following sample shows how these delivery policies can be set:

    SetSubscriptionAttributesRequest setRequest = new SetSubscriptionAttributesRequest()
        .WithSubscriptionArn(subArn)
        .WithAttributeName("DeliveryPolicy")
        .WithAttributeValue("{\"healthyRetryPolicy\":{\"numRetries\":10,\"minDelayTarget\":30,\"maxDelayTarget\":60}}");
                    

Amazon SNS Message Formatting gives you the ability to publish a message that contains content that is specific to each type of Subscription. You could, for example, send a short message to an SMS endpoint and a longer message to an email endpoint. To use this feature, you set the new MessageStructure parameter to "json" when you call the SNS publish function. The associated message body must contain a JSON object with a default message body and optional message bodies for other protocols.

The below code sample shows how this feature can be used:

    PublishRequest pubRequest = new PublishRequest()
        .WithTopicArn(topicArn)
        .WithMessageStructure("json")
        .WithMessage("{\"default\" : \"Server busy.\",\"email\":\"Your server is busy\",\"sms\" : \"ALERT! Server Busy!!\", \"https\" : \"ServerBusy\"}");