Download WebApiMongoDB.zip - 20.2 KB

Source could be also accessed from GitHub -> https://github.com/fpetru/WebApiMongoDB.

Updated on: 15 Nov 2017

Following Matthew’s comment, I have updated the interface INoteRepository to not be coupled to MongoDB libraries.

Please find the full list of updates at the end of the article

What we try to achieve

Problem / solution format brings an easier understanding on how to build things, giving an immediate feedback. Starting from this idea, the blog post will present step by step how to build

"A web application to store your ideas in an easy way, adding text notes, either from desktop or mobile, with few characteristics: run fast, save on the fly whatever you write, and be reasonably reliable and secure."

This blog post will implement just the backend, WebApi and the database access, in the most simple way. Next blog post, covers the front end, using Angular 2: Angular 2 with ASP.NET Core Web API – Build a simple Notebook app – Part 1

Topics covered

Technology stack
Configuration model
Options model
Dependency injection
MongoDb – Installation and configuration using MongoDB C# Driver v.2
Make a full ASP.NET WebApi project, connected async to MongoDB
Enable Cross Domain Calls (CORS)

You may be interested also in:

Link this project to Angular 2: ASP.NET Core Web API – Build a simple Notebook app – Part 1.
Run LINQ queries on large MongoDb collections: How to Search Good Places to Travel (MongoDb LINQ & .NET Core)
Paging in MongoDB – How to actually avoid poor performance ?

Technology stack

The ASP.NET Core Web API has the big advantage that it can be used as HTTP service and it can be subscribed by any client application, ranging from desktop to mobiles, and also be installed on Windows, macOS or Linux.

MongoDB is a popular NoSQL database that makes a great backend for Web APIs. These lend themselves more to document store type, rather than to relational databases. This blog will present how to build a .NET Core Web API connected asynchronously to MongoDB, with full support for HTTP GET, PUT, POST, and DELETE.

To install

Here are all the things needed to be installed:

Creating the ASP.NET WebApi project

Launch Visual Studio and then access File > New Project > .Net Core > ASP.NET Core Web Application.

and then select Web API with ASP.NET Core 2.0

Configuration

There are multiple file formats, supported out of the box for the configuration (JSON, XML, or INI). By default, the WebApi project template comes with JSON format enabled. Inside the setting file, order matters, and include complex structures. Here is an example with a 2 level settings structure for database connection.
AppSettings.json – update the file:

{
  "MongoConnection": {
    "ConnectionString": "mongodb://admin:abc123!@localhost",
    "Database": "NotesDb"
  },

  "Logging": {
    "IncludeScopes": false,
    "LogLevel": {
      "Default": "Debug",
      "System": "Information",
      "Microsoft": "Information"
    }
  }
}

Dependency injection and Options model

Constructor injection is one of the most common approach to implementing Dependency Injection (DI), though not the only one. ASP.NET Core uses constructor injection in its solution, so we will also use it. ASP.NET Core project has a Startup.cs file, which configures the environment in which our application will run. The Startup.cs file also places services into ASP.NET Core’s Services layer, which is what enables dependency injection.

To map the custom database connection settings, we will add a new Settings class.

namespace NotebookAppApi.Model
{
    public class Settings
    {
        public string ConnectionString;
        public string Database;
    }

Here is how we modify Startup.cs to inject Settings in the Options accessor model:

public void ConfigureServices(IServiceCollection services)
{
    // Add framework services.
    services.AddMvc();

    services.Configure<Settings>(options =>
    {
        options.ConnectionString = Configuration.GetSection("MongoConnection:ConnectionString").Value;
        options.Database = Configuration.GetSection("MongoConnection:Database").Value;
    });

Further in the project, settings will be access via IOptions interface:

IOptions<Settings>

MongoDB configuration

Once you have installed MongoDB, you would need to configure the access, as well as where the data is located.

To do this, create a file locally, named mongod.cfg. This will include setting path to the data folder for MongoDB server, as well as to the MongoDB log file. Please update these local paths, with your own settings:

systemLog:
  destination: file
  path: "C:\\tools\\mongodb\\db\\log\\mongo.log"
  logAppend: true
storage:
  dbPath: "C:\\tools\\mongodb\\db\\data"
security:
  authorization: enable

Run in command prompt next line. This will start the MongoDB server, pointing to the configuration file already created (in case the server is installed in a custom folder, please update first the command)

"C:\Program Files\MongoDB\Server\3.2\bin\mongod.exe" --config C:\Dev\Data.Config\mongod.cf

Once the server is started (and you could see the details in the log file), run mongo.exe in command prompt. The next step is to add the administrator user to the database. Run mongodb with the full path (ex: “C:\Program Files\MongoDB\Server\3.2\bin\mongo.exe”).

and then copy paste the next code in the console:

use admin
db.createUser(
  {
	user: "admin",
	pwd: "abc123!",
	roles: [ { role: "root", db: "admin" } ]
  }
);
exit;

MongoDB .NET Driver

To connect to MongoDB, add via Nuget the package named MongoDB.Driver. This is the new official driver for .NET, fully supporting the ASP.NET Core applications.

Model

The model class (POCO) associated with each entry in the notebook is included below:

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

namespace NotebookAppApi.Model
{
    public class Note
    {
        [BsonId]
        public string Id { get; set; }
        public string Body { get; set; } = string.Empty;
        public DateTime UpdatedOn { get; set; } = DateTime.Now;
        public DateTime CreatedOn { get; set; } = DateTime.Now;
        public int UserId { get; set; } = 0;
    }
}

Defining the database context

In order to keep the functions for accessing the database in a distinct place, we will add a NoteContext class. This will use the Settings defined above.

public class NoteContext
{
    private readonly IMongoDatabase _database = null;

    public NoteContext(IOptions<Settings> settings)
    {
        var client = new MongoClient(settings.Value.ConnectionString);
        if (client != null)
            _database = client.GetDatabase(settings.Value.Database);
    }

    public IMongoCollection<Note> Notes
    {
        get
        {
            return _database.GetCollection<Note>("Note");
        }
    }
}

Adding the repository

Using a repository interface, we will implement the functions needed to manage the Notes. These will also use Dependency Injection (DI) to be easily access from the application (e.g. controller section):

public interface INoteRepository
{
    Task<IEnumerable<Note>> GetAllNotes();
    Task<Note> GetNote(string id);
    Task AddNote(Note item);
    Task<bool> RemoveNote(string id);
    Task<bool> UpdateNote(string id, string body);
    Task<bool> UpdateNoteDocument(string id, string body);
    Task<bool> RemoveAllNotes();
}

The access to database will be asynchronous. We are using here the new driver, which offers a full async stack.

Just as an example: to get all the Notes, we make an async request:

public async Task<IEnumerable<Note>> GetAllNotes()
{
    return await _context.Notes.Find(_ => true).ToListAsync();
}

Here is the full implementation, for all basic CRUD operations:

public class NoteRepository : INoteRepository
{
    private readonly NoteContext _context = null;

    public NoteRepository(IOptions<Settings> settings)
    {
        _context = new NoteContext(settings);
    }

    public async Task<IEnumerable<Note>> GetAllNotes()
    {
        try
        {
            return await _context.Notes
                    .Find(_ => true).ToListAsync();
        }
        catch (Exception ex)
        {
            // log or manage the exception
            throw ex;
        }
    }

    public async Task<Note> GetNote(string id)
    {
        var filter = Builders<Note>.Filter.Eq("Id", id);

        try
        {
            return await _context.Notes
                            .Find(filter)
                            .FirstOrDefaultAsync();
        }
        catch (Exception ex)
        {
            // log or manage the exception
            throw ex;
        }
    }

    public async Task AddNote(Note item)
    {
        try
        {
            await _context.Notes.InsertOneAsync(item);
        }
        catch (Exception ex)
        {
            // log or manage the exception
            throw ex;
        }
    }

    public async Task<bool> RemoveNote(string id)
    {
        try
        {
            DeleteResult actionResult = await _context.Notes.DeleteOneAsync(
                    Builders<Note>.Filter.Eq("Id", id));

            return actionResult.IsAcknowledged 
                && actionResult.DeletedCount > 0;
        }
        catch (Exception ex)
        {
            // log or manage the exception
            throw ex;
        }
    }

    public async Task<bool> UpdateNote(string id, string body)
    {
        var filter = Builders<Note>.Filter.Eq(s => s.Id, id);
        var update = Builders<Note>.Update
                        .Set(s => s.Body, body)
                        .CurrentDate(s => s.UpdatedOn);

        try
        {
            UpdateResult actionResult
                 = await _context.Notes.UpdateOneAsync(filter, update);

            return actionResult.IsAcknowledged
                && actionResult.ModifiedCount > 0;
        }
        catch (Exception ex)
        {
            // log or manage the exception
            throw ex;
        }
    }

    public async Task<bool> UpdateNote(string id, Note item)
    {
        try
        {
            ReplaceOneResult actionResult 
                = await _context.Notes
                                .ReplaceOneAsync(n => n.Id.Equals(id)
                                        , item
                                        , new UpdateOptions { IsUpsert = true });
            return actionResult.IsAcknowledged
                && actionResult.ModifiedCount > 0;
        }
        catch (Exception ex)
        {
            // log or manage the exception
            throw ex;
        }
    }

    public async Task<bool> RemoveAllNotes()
    {
        try
        {
            DeleteResult actionResult 
                = await _context.Notes.DeleteManyAsync(new BsonDocument());

            return actionResult.IsAcknowledged
                && actionResult.DeletedCount > 0;
        }
        catch (Exception ex)
        {
            // log or manage the exception
            throw ex;
        }
    }
}

In order to access NoteRepository using DI model, we add a new line in ConfigureServices

services.AddTransient<INoteRepository, NoteRepository>()

where:

Transient: Created each time.
Scoped: Created only once per request.
Singleton: Created the first time they are requested. Each subsequent request uses the instance that was created the first time.

Adding the main controller

First we present the main controller. It provides all the CRUD interfaces, available to external applications.

[Route("api/[controller]")]
public class NotesController : Controller
{
    private readonly INoteRepository _noteRepository;

    public NotesController(INoteRepository noteRepository)
    {
        _noteRepository = noteRepository;
    }

    // GET: notes/notes
    [HttpGet]
    public Task<string> Get()
    {
        return GetNoteInternal();
    }

    private async Task<string> GetNoteInternal()
    {
        var notes = await _noteRepository.GetAllNotes();
        return JsonConvert.SerializeObject(notes);
    }

    // GET api/notes/5
    [HttpGet("{id}")]
    public Task<string> Get(string id)
    {
        return GetNoteByIdInternal(id);
    }

    private async Task<string> GetNoteByIdInternal(string id)
    {
        var note = await _noteRepository.GetNote(id) ?? new Note();
        return JsonConvert.SerializeObject(note);
    }

    // POST api/notes
    [HttpPost]
    public void Post([FromBody]string value)
    {
        _noteRepository.AddNote(new Note() 
           { Body = value, CreatedOn = DateTime.Now, UpdatedOn = DateTime.Now });
    }

    // PUT api/notes/5
    [HttpPut("{id}")]
    public void Put(string id, [FromBody]string value)
    {
        _noteRepository.UpdateNote(id, value);
    }

    // DELETE api/notes/5
    public void Delete(string id)
    {
        _noteRepository.RemoveNote(id);
    }

Adding the admin controller

This will be a controller dedicated to administrative tasks (we use to initialize the database with some dummy data). In real projects, we should very cautiously use such interface. For development only and quick testing purpose, this approach may be convenient.

To use it, we will just add the url in the browser. Running the code below, the full setup will be automatically created (e.g. new database, new collection, sample records). We can use either http://localhost:5000/system/init or http://localhost:53617/api/system/init (when using IIS). We could even extend the idea, adding more commands. However, as mentioned above, these kind of scenarios should be used just for development, and be never deployed to a production environment.

[Route("api/[controller]")]
public class SystemController : Controller
{
    private readonly INoteRepository _noteRepository;

    public SystemController(INoteRepository noteRepository)
    {
        _noteRepository = noteRepository;
    }

    // Call an initialization - api/system/init
    [HttpGet("{setting}")]
    public string Get(string setting)
    {
        if (setting == "init")
        {
            _noteRepository.RemoveAllNotes();
            _noteRepository.AddNote(new Note() { Id = "1", Body = "Test note 1", 
                          CreatedOn = DateTime.Now, 
                          UpdatedOn = DateTime.Now, UserId = 1 });
            _noteRepository.AddNote(new Note() { Id = "2", Body = "Test note 2", 
                          CreatedOn = DateTime.Now, 
                          UpdatedOn = DateTime.Now, UserId = 1 });
            _noteRepository.AddNote(new Note() { Id = "3", Body = "Test note 3", 
                          CreatedOn = DateTime.Now, 
                          UpdatedOn = DateTime.Now, UserId = 2 });
            _noteRepository.AddNote(new Note() { Id = "4", Body = "Test note 4", 
                          CreatedOn = DateTime.Now, 
                          UpdatedOn = DateTime.Now, UserId = 2 });

            return "Done";
        }

        return "Unknown";
    }
}

Launch settings

In order to have a quick display of the values, once the project will run, please update the file launchSettings.json.

Here is the full file content, pointing by default to api/notes url.

{
  "iisSettings": {
    "windowsAuthentication": false,
    "anonymousAuthentication": true,
    "iisExpress": {
      "applicationUrl": "http://localhost:53617/",
      "sslPort": 0
    }
  },
  "profiles": {
    "IIS Express": {
      "commandName": "IISExpress",
      "launchBrowser": true,
      "launchUrl": "api/notes",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    },
    "NotebookAppApi": {
      "commandName": "Project",
      "launchBrowser": true,
      "launchUrl": "http://localhost:5000/api/notes",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    }
  }
}

Running the project

Before running the project, please make sure the MongoDB is running (either as an Windows Service, or via console application, as presented above).

Run first the initialization link:
http://localhost:53617/api/system/init

and then run the default application link
http://localhost:53617/api/notes

Use Robomongo

Using Robomongo we could check the actual entries inside the database. Connecting to the database, using the credentials, we could see all 4 records.

Fully update the MongoDB documents

Initially the sample project included only selective update of the properties. Using ReplaceOneAsync we could update the full document. Upsert creates the document, in case it doesn’t already exist.

public async Task<replaceoneresult> UpdateNote(string id, Note item)
{
     return await _context.Notes
                          .ReplaceOneAsync(n => n.Id.Equals(id)
                                            , item
                                            , new UpdateOptions { IsUpsert = true });
} 
</replaceoneresult>

Test the update

To be able to test the update, I have used Postman. It is an excellent tool to test APIs.

I have selected the command type POST, then entered the local URL, and added a new Header (Content-Type as application/json).

ASP.NET Core WebAPI Set-header

And then set the Body as raw and updated a dummy value.

ASP.NET Core WebAPI Make the request

Using RoboMongo we can see the value updated.

MongoDB .NET Driver Updated document in Robomongo

Exception management

Starting with C# 5.0 async and await were introduced into the language to simplify using the Task Parallel Library. We can simply use a try/catch block to catch an exception, like so:

public async Task<ienumerable<note>> GetAllNotes()
{
    try
    {
        return await _context.Notes.Find(_ => true).ToListAsync();
    }
    catch (Exception ex)
    {
        // log or manage the exception
        throw ex;
    }
}
</ienumerable<note>

In this way we handle a faulted task by asynchronously wait for it to complete, using await. This will rethrow the original stored exception. Initially I have used void as return. Changing the return type, the exception raised in the async method will get safely saved in the returning Task instance. When we await the faulty method, the exception saved in the Task will get rethrown with its full stack trace preserved.

public async Task AddNote(Note item)
{
    try
    {
        await _context.Notes.InsertOneAsync(item);
    }
    catch (Exception ex)
    {
        // log or manage the exception
        throw ex;
    }
}

"No 'Access-Control-Allow-Origin' header is present on the requested resource."

The error

Trying to consume the service from Angular 2.0, see here the CodeProject article, I have ran into this error.

Why this error appeared ?

Being different applications, running on seperate domains, all calls back to ASP.NET WebAPI site are effectively cross domain calls. With Angular 2, there is first a preflight request, before the actual request, which is an OPTIONS request. Doing this pre-check, we verify first that cross domain calls are allowed (CORS).

How I have enabled them ?

To do this I have made 2 changes:

Registered CORS functionality in ConfigureServices() of Startup.cs:

 public void ConfigureServices(IServiceCollection services) 
 {
      // Add service and create Policy with options 
      services.AddCors(options => { options.AddPolicy("CorsPolicy", 
                                      builder => builder.AllowAnyOrigin() 
                                                        .AllowAnyMethod() 
                                                        .AllowAnyHeader() 
                                                        .AllowCredentials()); 
                                  }); 
      // .... 

      services.AddMvc(); 
 }

And then enabled the policy globally to every request in the application by call app.useCors() in the Configure()method of Startup, before UseMVC.

 public void Configure(IApplicationBuilder app) 
 { 
    // ... 

    // global policy, if assigned here (it could be defined indvidually for each controller) 
    app.UseCors("CorsPolicy"); 

    // ... 

    // We define UseCors() BEFORE UseMvc, below just a partial call
    app.UseMvc(routes => {
 }

Does this have any impact to the other parts of solution ?

No, this refers just to this security policy. Even if this could be further and more selective applied, the rest of the project remains unchanged.

Changes to original article

Update on: 15 Nov 2017

Following Matthew’s comment, I have updated the interface INoteRepository to not be coupled to MongoDB libraries.

Update on: 23 Sep 2017

The project runs now with .NET Core 2.0.

Update 16 Aug 2017

Added the reference to other two articles on MongoDb:

Update 13 Apr 2017

Converted the project to Visual Studio 2017.

Update 14 Dec 2016

Following Marcello's comment, I have added a basic level of exception management.

Update 07 Dec 2016

I have extended the update function, making possible to modify full MongoDB documents at once, not just to some of the properties. There is a new section at the end of the article, describing this change.
I have updated the project to .NET Core 1.1 as well to MongoDB .NET Driver 2.4.

Update 25 Nov 2016

Trying to consume the service from Angular 2.0, see here the CodeProject article, I have ran into CORS problems: "No 'Access-Control-Allow-Origin' header is present on the requested resource." I have extended the article to solve this issue.

Using MongoDB .NET Driver with .NET Core WebAPI