CRUD Operations In Azure Cosmos DB SQL API Using ASP.NET Core Web API C#

[HttpPost]
public async Task < IActionResult > AddEmployee(EmployeeModel employee) {
    try {
        var container = ContainerClient();
        var response = await container.CreateItemAsync(employee, new PartitionKey(employee.Department));
        return Ok(response);
    } catch (Exception ex) {
        return BadRequest(ex.Message);
    }
}

As explained in step 2, we are passing the ID and Department as a partition key as part of the employee input payload while adding the employee details. These parameters must be part of the input parameter payload.

Step 8: Create a Method to Get Employees

Add the following code into the EmployeeController.cs class to get all the employees from the Cosmos database.

[HttpGet]
public async Task < IActionResult > GetEmployeeDetails() {
    try {
        var container = ContainerClient();
        var sqlQuery = "SELECT * FROM c";
        QueryDefinition queryDefinition = new QueryDefinition(sqlQuery);
        FeedIterator < EmployeeModel > queryResultSetIterator = container.GetItemQueryIterator < EmployeeModel > (queryDefinition);
        List < EmployeeModel > employees = new List < EmployeeModel > ();
        while (queryResultSetIterator.HasMoreResults) {
            FeedResponse < EmployeeModel > currentResultSet = await queryResultSetIterator.ReadNextAsync();
            foreach(EmployeeModel employee in currentResultSet) {
                employees.Add(employee);
            }
        }
        return Ok(employees);
    } catch (Exception ex) {
        return BadRequest(ex.Message);
    }
}

This example is not a good practice since we are fetching all the employees without paging or a partition key filter, but we are doing this to learn how it works without making it complicated. In the next article, I will show how to get a list of records with the paging.

Step 9: Create a Method to Get Employee by ID

Create the GetEmployeeDetailsById method in the EmployeeController.cs and add the following code to get the employee by employeeId and partition key from the Cosmos database.

[HttpGet]
public async Task < IActionResult > GetEmployeeDetailsById(string employeeId, string partitionKey) {
    try {
        var container = ContainerClient();
        ItemResponse < EmployeeModel > response = await container.ReadItemAsync < EmployeeModel > (employeeId, new PartitionKey(partitionKey));
        return Ok(response.Resource);
    } catch (Exception ex) {
        return BadRequest(ex.Message);
    }
}

Step 10: Create a Method to Update Employee

Create the UpdateEmployee method in the EmployeeController.cs and add the following code to update the employee by employeeId and partition key.

The CosmosDB does not support the partial update feature; rather, it actually replaces the existing item by getting the document to be updated and sending the same details to the database after fields change or update.

[HttpPut]
public async Task < IActionResult > UpdateEmployee(EmployeeModel emp, string partitionKey) {
    try {
        var container = ContainerClient();
        ItemResponse < EmployeeModel > res = await container.ReadItemAsync < EmployeeModel > (emp.id, new PartitionKey(partitionKey));
        //Get Existing Item
        var existingItem = res.Resource;
        //Replace existing item values with new values 
        existingItem.Name = emp.Name;
        existingItem.Country = emp.Country;
        existingItem.City = emp.City;
        existingItem.Department = emp.Department;
        existingItem.Designation = emp.Designation;
        var updateRes = await container.ReplaceItemAsync(existingItem, emp.id, new PartitionKey(partitionKey));
        return Ok(updateRes.Resource);
    } catch (Exception ex) {
        return BadRequest(ex.Message);
    }
}

Step 11: Create a Method to Delete Employee

Create the DeleteEmployee method in the EmployeeController.cs and add the following code to delete the employee by employeeId and partition key.

[HttpDelete]
public async Task < IActionResult > DeleteEmployee(string empId, string partitionKey) {
    try {
        var container = ContainerClient();
        var response = await container.DeleteItemAsync < EmployeeModel > (empId, new PartitionKey(partitionKey));
        return Ok(response.StatusCode);
    } catch (Exception ex) {
        return BadRequest(ex.Message);
    }
  }
}

The entire code of the EmployeeController.cs class file will look like the following after adding all the methods together:

EmployeeController.cs

using EmployeeManagement.Model;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.Cosmos;
namespace EmployeeManagement.Controllers {
    [ApiController]
    [Route("api/[controller]/[action]")]
    public class EmployeeController: ControllerBase {
        // Cosmos DB details, In real use cases, these details should be configured in secure configuraion file.
        private readonly string CosmosDBAccountUri = "https://localhost:8081/";
        private readonly string CosmosDBAccountPrimaryKey = "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==";
        private readonly string CosmosDbName = "EmployeeManagementDB";
        private readonly string CosmosDbContainerName = "Employees";
        /// <summary>
        /// Commom Container Client, you can also pass the configuration paramter dynamically.
        /// </summary>
        /// <returns> Container Client </returns>
        private Container ContainerClient() {
                CosmosClient cosmosDbClient = new CosmosClient(CosmosDBAccountUri, CosmosDBAccountPrimaryKey);
                Container containerClient = cosmosDbClient.GetContainer(CosmosDbName, CosmosDbContainerName);
                return containerClient;
            }
            [HttpPost]
        public async Task < IActionResult > AddEmployee(EmployeeModel employee) {
                try {
                    var container = ContainerClient();
                    var response = await container.CreateItemAsync(employee, new PartitionKey(employee.Department));
                    return Ok(response);
                } catch (Exception ex) {
                    return BadRequest(ex.Message);
                }
            }
            [HttpGet]
        public async Task < IActionResult > GetEmployeeDetails() {
                try {
                    var container = ContainerClient();
                    var sqlQuery = "SELECT * FROM c";
                    QueryDefinition queryDefinition = new QueryDefinition(sqlQuery);
                    FeedIterator < EmployeeModel > queryResultSetIterator = container.GetItemQueryIterator < EmployeeModel > (queryDefinition);
                    List < EmployeeModel > employees = new List < EmployeeModel > ();
                    while (queryResultSetIterator.HasMoreResults) {
                        FeedResponse < EmployeeModel > currentResultSet = await queryResultSetIterator.ReadNextAsync();
                        foreach(EmployeeModel employee in currentResultSet) {
                            employees.Add(employee);
                        }
                    }
                    return Ok(employees);
                } catch (Exception ex) {
                    return BadRequest(ex.Message);
                }
            }
            [HttpGet]
        public async Task < IActionResult > GetEmployeeDetailsById(string employeeId, string partitionKey) {
                try {
                    var container = ContainerClient();
                    ItemResponse < EmployeeModel > response = await container.ReadItemAsync < EmployeeModel > (employeeId, new PartitionKey(partitionKey));
                    return Ok(response.Resource);
                } catch (Exception ex) {
                    return BadRequest(ex.Message);
                }
            }
            [HttpPut]
        public async Task < IActionResult > UpdateEmployee(EmployeeModel emp, string partitionKey) {
                try {
                    var container = ContainerClient();
                    ItemResponse < EmployeeModel > res = await container.ReadItemAsync < EmployeeModel > (emp.id, new PartitionKey(partitionKey));
                    //Get Existing Item
                    var existingItem = res.Resource;
                    //Replace existing item values with new values 
                    existingItem.Name = emp.Name;
                    existingItem.Country = emp.Country;
                    existingItem.City = emp.City;
                    existingItem.Department = emp.Department;
                    existingItem.Designation = emp.Designation;
                    var updateRes = await container.ReplaceItemAsync(existingItem, emp.id, new PartitionKey(partitionKey));
                    return Ok(updateRes.Resource);
                } catch (Exception ex) {
                    return BadRequest(ex.Message);
                }
            }
            [HttpDelete]
        public async Task < IActionResult > DeleteEmployee(string empId, string partitionKey) {
            try {
                var container = ContainerClient();
                var response = await container.DeleteItemAsync < EmployeeModel > (empId, new PartitionKey(partitionKey));
                return Ok(response.StatusCode);
            } catch (Exception ex) {
                return BadRequest(ex.Message);
            }
        }
    }
}

Now, we have all the code and required configuration to work with Azure CosmosDB in our sample application.

Step 12: Run the ASP.NET Core API Application

Now press Keyboard F5 or the Visual Studio Run button to run the application. After running the application, the following screen will be shown in the browser with swagger UI having all the methods which we have created in our ASP.NET core web API, as shown in the following screenshot:

Now, we will test the functionality by using the Swagger UI, but you can use Postman or any other tool to execute the API endpoints.

Step 13: Azure Cosmos DB CRUD Demo

The following animated image shows how the insert, read, update, and delete operations of Azure Cosmos DB work.

Add Employees

Get List of Employees and Employee by Id

Update the Employee

Delete the Employee by Id

Summary

I hope, from all the examples above, you have learned how to insert, read, update, and delete data from Azure Cosmos DB using ASP.NET Core API C#. If you like it, share it with your friends and beginners, or any doubts or suggestions, then please those using the comment box.

Read more articles on ASP.NET,

• How To Create ASP.NET Core MVC Application
• Hosting ASP.NET Web API REST Service On IIS 10
• Publishing ASP.NET Web API REST Service Using File System Method
• Building And Running ASP.NET Core Application In Docker Container