Using MongoDB With ASP.NET Core Web API

Introduction

 

A common thing we hear in all places these days is NoSQL databases. These are being very strongly promoted by all vendors. One of the most common NoSQL databases these days is MongoDB. In this article we will discuss what a NoSQL database is, when it must be used and then we will look at an example to install, create and populate this database. Finally, we will look at how to access data from this database using a ASP.NET Core Web API.

 

What is a NoSQL database?

 

So, what exactly is a NoSQL database? It is a collection of documents with no real defined structure as in an RDBMS or SQL database. That means that we do not have any pre-defined columns as we do have in a SQL table. We simply store each row with its own number of columns or data fields as we may call them. Hence, we have a large store of documents (similar to rows in a SQL database with no predefined structure) organized into a collection (similar to tables in a SQL database) which are inside a database (similar to a database in a SQL database). So, what is the advantage of a NoSQL database? Well, for one, the data for each document is in one place and faster to read. Secondly, as there is no pre-defined structure we can store documents with different fields in one place and do not have to worry about adding new columns each time where most rows could contain NULLS as in a SQL database. Also, it saves us from creating new tables with relationships.

 

What is MongoDB?

 

MongoDB is one of the most common NoSQL databases out there from MongoDB Inc. Being a Microsoft developer, another well known NoSQL database is Cosmos DB in addition to the tables storage mechanism in Microsoft Azure. MongoDB can be downloaded and run from your desktop computer. It runs as a service. It also comes with a client called “MongoDB Compass Community”. This is a nice compact client which allows you to connect to the instance running, view the databases, collections, and documents inside it. It also allows you to create new databases, new collections inside the database, and new documents inside the collection using the JSON format. There are also other clients that you can use with the MongoDB server like Studio 3T etc.

 

Installing MongoDB and creating the database elements

 

The first step would be to download and install the MongoDB Server and Client. You can do this from the below URL:

https://www.mongodb.com/download-center/community

 

Once you have downloaded the MSI package, you can install it as shown below:

 

 

Remember to install the “MongoDB Compass Community” client as well. Once, the installation is complete, you can confirm that the service for MongoDB is running as shown below:

 

We now open the client and see the below screenshot:

 

 

Here, we create a new database called “EmployeeDB” and collection called “Employees” as shown below:

 

 

Once these two elements of the NoSQL database are created, we will add some documents to the collection as shown below:

 

 

 

 

We add data using the JSON format. Once the data is entered, we can also do some searching like using the SELECT statement in a SQL database. See below where we are finding all records with the given phone number.

 

 

Here you see that a unique object Id has been assigned to each document. We can use this object ID to update documents in the collection.

 

Accessing the MongoDB database from an ASP.NET Core Web API application

 

Finally, we will see how we can access the data from the MongoDB database. For this, we will create a ASP.NET Core 3.1 Web API application as shown below:

 

 

 

The first thing we will do is to add the MongoDB driver NuGet package. This will allow us to access the MongoDB database via friendly APIs.

 

 

Once this is done, we can proceed to start adding the code.

 

We first create a new folder called “Models” and add a new class “Employee.cs” to it as shown below:

using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;

namespace MongoDBWebAPI.Models
{
    public class Employee
    {
        [BsonId]
        [BsonRepresentation(BsonType.ObjectId)]
        public string Id { get; set; }

        public string Name { get; set; }

        public string Address { get; set; }

        public string Phone { get; set; }

        public string Email { get; set; }

    }
}

We would also like to read the MongoDB settings from the appsettings.config file, using a strongly typed class and would hence create a new class file named “EmployeeDatabasesetting.cs” as below.

 

Appsettings.json

{
  "EmployeeDatabaseSettings": {
    "EmployeesCollectionName": "Employees",
    "ConnectionString": "mongodb://localhost:27017",
    "DatabaseName": "EmployeeDB"
  },
    "Logging": {
      "LogLevel": {
        "Default": "Information",
        "Microsoft": "Warning",
        "Microsoft.Hosting.Lifetime": "Information"
      }
    },
    "AllowedHosts": "*"
}

EmployeeDatabasesetting.cs

namespace MongoDBWebAPI.Models
{
    public class EmployeeDatabaseSettings : IEmployeeDatabaseSettings
    {
        public string EmployeesCollectionName { get; set; }
        public string ConnectionString { get; set; }
        public string DatabaseName { get; set; }
    }

    public interface IEmployeeDatabaseSettings
    {
        public string EmployeesCollectionName { get; set; }
        public string ConnectionString { get; set; }
        public string DatabaseName { get; set; }
    }
}

We do not want to call the Mongo API code directly from our controller class and hence we will create a service layer. For this, create a new folder called “Services” and add a new class called “EmployeeService.cs” to it as shown below:

using MongoDB.Driver;
using MongoDBWebAPI.Models;
using System.Collections.Generic;
using System.Linq;


namespace MongoDBWebAPI.Services
{
    public class EmployeeService
    {
        private readonly IMongoCollection<Employee> _employees;
        public EmployeeService(IEmployeeDatabaseSettings settings)
        {
            var client = new MongoClient(settings.ConnectionString);
            var database = client.GetDatabase(settings.DatabaseName);

            _employees = database.GetCollection<Employee>(settings.EmployeesCollectionName);

        }

        public List<Employee> Get()
        {
            List<Employee> employees;
            employees = _employees.Find(emp => true).ToList();
            return employees;
        }

        public Employee Get(string id) =>
            _employees.Find<Employee>(emp => emp.Id == id).FirstOrDefault();

    }
}

Next, we add a new controller called “EmployeesController” as shown below:

using System.Collections.Generic;
using Microsoft.AspNetCore.Mvc;
using MongoDBWebAPI.Models;
using MongoDBWebAPI.Services;

namespace MongoDBWebAPI.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class EmployeesController : ControllerBase
    {
        private readonly EmployeeService _employeeService;

        public EmployeesController(EmployeeService employeeService)
        {
            _employeeService = employeeService;
        }

        [HttpGet]
        public ActionResult<List<Employee>> Get() =>
            _employeeService.Get();

        [HttpGet("{id:length(24)}", Name = "GetEmployee")]
        public ActionResult<Employee> Get(string id)
        {
            var emp = _employeeService.Get(id);

            if (emp == null)
            {
                return NotFound();
            }

            return emp;
        }

    }
}

The final step is to configure the required services in the Startup.cs file as shown below:

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Options;
using MongoDBWebAPI.Models;
using MongoDBWebAPI.Services;

namespace MongoDBWebAPI
{
    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.Configure<EmployeeDatabaseSettings>(
                Configuration.GetSection(nameof(EmployeeDatabaseSettings)));

            services.AddSingleton<IEmployeeDatabaseSettings>(sp =>
                sp.GetRequiredService<IOptions<EmployeeDatabaseSettings>>().Value);

            services.AddSingleton<EmployeeService>();

            services.AddControllers();
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseHttpsRedirection();

            app.UseRouting();

            app.UseAuthorization();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
            });
        }
    }
}

We can now run the application and browse to the Employees Controller as shown below:

 

 

 

Summary

 

In this article, we looked at NoSQL databases and MongoDB in particular. We saw how to install MongoDB and do some basic operations on it. This included creating a new database in the instance running on our machine, creating a collection inside the database, and then adding data called documents inside the collection. We then saw how to connect to MongoDB from an ASP.NET Core Web API application and how to read the data from the MongoDB database.