CRUD Operations with Azure Table Storage in an Azure Function – C

In this series of byte sized tutorials, we will create an Azure Function for Crud Operations on an Azure Storage Table. For the demonstration, we will stick a basic web function, which would enable us to do the CRUD operations for a TODO table.

The reason to pick Azure Storage table is primarly it is extremely cost efficient and you could also emulate the storage within your development environment.That’s true, you do not need even a Azure subscription to try out Azure Storage, thanks the Storage Emulator.

One of the key points to remember before we proceed is how an Entity is identified uniquely in a Azure Table Storage. Partitions allows scaling of the system easily and whenever you store an item in the table, it is stored in a partition, which is scaled out in the system. The PartionId allows to uniquely identify the partition in which the data resides. The RowId, uniquely identifies the specific entity within the Partition and together with ParitionKey forms the composite key that would be unique identifier for your entity.

We will get back to this a bit later. But for now, we will define our Entity derieved from TableEntity.

using Microsoft.Azure.Cosmos.Table;
public class TodoTableEntity : TableEntity
{
    public string Title { get; set; }
    public string Description { get; set; }
    public bool IsCompleted { get; set; }
}

We require 3 columns in our Table in addition to the PartionKeyRowKey, and TimeStamp.

We will begin by writing the basic skeleton code for our web function and go through the key components, before the insert operation.

[FunctionName("TodoAdd")]
public static async Task<IActionResult> Add(
    [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
    [Table("todos")] CloudTable todoTable,
    ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
    var data = JsonConvert.DeserializeObject<TodoDto>(requestBody);

    // TODO

    return new OkObjectResult(0);
}

public class TodoDto
{
    public string Title { get; set; }
    public string Description { get; set; }
    public bool IsCompletd { get; set; }
}

The function defined above (TodoAdd) accepts a HttpTrigger (both Get and Post requests). The data to be inserted is passed via the Request Body. We will use the HttpRequest.Body property to read the information and deserialize them. This is quite evident in the code above. What is of more interest at this point is the todoTable parameter.

The todoTable parameter, of type CloudTable represents a table in Microsoft Azure Table Service and provides us all the methods required to access the table. The bindings specify that the table is named todos.

Now that we have our data to be deserialized and the table name, we would proceed to insert the data in the table.

var dataToInsert = new TodoTableEntity
{
    Title = data.Title,
    Description = data.Description,
    IsCompleted = data.IsCompletd,
    PartitionKey = data.Title[0].ToString(),
    RowKey = data.Title[0].ToString()
};


var addEntryOperation = TableOperation.Insert(dataToInsert);
todoTable.CreateIfNotExists();
await todoTable.ExecuteAsync(addEntryOperation);


As mentioned earlier the CloudTable provides us with all the necessary ammuniation to access the table. In this case, we would be using the CloudTable.ExecuteAsync method to execute a TableOperation to insert the record.

However, the following code has a serious flaw, which we will discuss in a moment. Consider the Entity we are about to insert.

var dataToInsert = new TodoTableEntity
{
    Title = data.Title,
    Description = data.Description,
    IsCompleted = data.IsCompletd,
    PartitionKey = data.Title[0].ToString(),
    RowKey = data.Title[0].ToString() // This causes an error
};

After filling the Title,Description and IsCompleted fields from the data we recieved from the Http Request, we are also assigning the PartitionKey and RowKey to the entity. We have decided, for the sake of example, to partition the table based the first alphabet of the Title. This works fine – we would end up with multiple partitions. However, the RowKey would cause an issue. Consider the following two requests.

// First Request
{
    title:'A Test',
    description:'A Test Description`,
    isCompleted:'false`
}
// Second Request
{
    title:'Another Test',
    description:'A Test Description`,
    isCompleted:'false`
}

Both these request would have PartitionKey value as “A” according to the code we wrote above. This is fine, as would want to group all the Entities with title starting with “A” in the same partition. However, the above code would also result in both the RowId to be same as well. This leads to an error as these needs to be separate entities and cannot share the same combination of PartitionKey and RowId.

For this reason, we will need a unique Id to identify the RowId. In this example, we will use a simple technique in which we will create another partition, namely Key, which would contain a single Row. This Row would contain a numerical value which we would use as the Identity value to be used in the table. With each request, we would also need to update the key.

So let us rewrite the code again to make use of the Key entity.

[FunctionName("TodoAdd")]
public static async Task<IActionResult> Add(
    [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
    [Table("todos","Key","Key",Take =1)] TodoKey keyGen,
    [Table("todos")] CloudTable todoTable,
    ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    string name = req.Query["name"];

    string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
    var data = JsonConvert.DeserializeObject<TodoDto>(requestBody);

    if (keyGen == null)
    {
        keyGen = new TodoKey
        {
            Key = 1000,
            PartitionKey = "Key",
            RowKey = "Key"
        };

        var addKeyOperation = TableOperation.Insert(keyGen);
        await todoTable.ExecuteAsync(addKeyOperation);
    }

    var rowKey = keyGen.Key;

    var dataToInsert = new TodoTableEntity
    {
        Title = data.Title,
        Description = data.Description,
        IsCompleted = data.IsCompletd,
        PartitionKey = data.Title[0].ToString(),
        RowKey = keyGen.Key.ToString()
    };

    keyGen.Key += 1;
    var updateKeyOperation = TableOperation.Replace(keyGen);
    await todoTable.ExecuteAsync(updateKeyOperation);
    var addEntryOperation = TableOperation.Insert(dataToInsert);
    todoTable.CreateIfNotExists();
    await todoTable.ExecuteAsync(addEntryOperation);

    return new OkObjectResult(keyGen.Key);
}

As observed in the code above, we have introduced a new parameter keyGen, which points to the new entity in the same todos table. We have used the bindings to specify the ParitionKey and RowKey to fetch the entity for us.

We then increment the Key, and use it as the RowId for rest of our entities. The resultant table storage would look like following.

In this example, we have create a simple Create Operation for Azure Table Storage. We will explore more into the Azure Bindings and rest of CRUD Operations in rest of the series, but hope this provides a good starting point for learning Azure Storage with Azure functions.