Tutorial: Create a RESTful API with the .NET/C# Driver Driver

Create the MongoDBSettings class

Your MongoDB service is responsible for establishing a connection and directly working with documents within MongoDB. In your project, create a folder named Models. In the Models folder, create a new file named MongoDBSettings.cs. In this file, add the following code:

namespace MongoExample.Models;
public class MongoDBSettings {
    public string ConnectionURI { get; set; } = null!;
    public string DatabaseName { get; set; } = null!;
    public string CollectionName { get; set; } = null!;
}

The preceding code defines a class named MongoDBSettings that contains information about your connection, the database name, and the collection name.

Update the appsettings.json file

The data that will be stored in the class fields defined in the MongoDBSettings class is found in the projects' appsettings.json file. Open this file and add the following configuration:

{
   "Logging": {
      "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
      }
   },
"AllowedHosts": "*",
"MongoDB": {
   "ConnectionURI": "<Atlas connection string>",
   "DatabaseName": "sample_mflix",
   "CollectionName": "playlist"
   }
}

This tutorial uses the sample_mflix database and the playlist collection. Replace the <Atlas connection string> placeholder with your MongoDB Atlas connection string. For more information on how to find your connection string, see the Connect to Your Cluster tutorial.

Create the service

In your project, create a folder named Services. In the Services folder, create a new file named MongoDBService.cs and add the following code:

using MongoExample.Models;
using Microsoft.Extensions.Options;
using MongoDB.Driver;
using MongoDB.Bson;
namespace MongoExample.Services;
public class MongoDBService {
    private readonly IMongoCollection<Playlist> _playlistCollection;
    public MongoDBService(IOptions<MongoDBSettings> mongoDBSettings) {
        MongoClient client = new MongoClient(mongoDBSettings.Value.ConnectionURI);
        IMongoDatabase database = client.GetDatabase(mongoDBSettings.Value.DatabaseName);
        _playlistCollection = database.GetCollection<Playlist>(mongoDBSettings.Value.CollectionName);
    }
    public async Task<List<Playlist>> GetAsync() { }
    public async Task CreateAsync(Playlist playlist) { }
    public async Task AddToPlaylistAsync(string id, string movieId) {}
    public async Task DeleteAsync(string id) { }
}

The preceding code defines a class named MongoDBService that includes empty asynchronous functions. Throughout this tutorial, you add code to these functions as you create your endpoints. The settings you configured in the appsettings.json file are set to variables.

Connect the service to the application

Open the Program.cs file and add the following code to the top of the file:

using MongoExample.Models;
using MongoExample.Services;
var builder = WebApplication.CreateBuilder(args);
builder.Services.Configure<MongoDBSettings>(builder.Configuration.GetSection("MongoDB"));
builder.Services.AddSingleton<MongoDBService>();

In the preceding code, the GetSection() function pulls your settings from the MongoDB field in the appsettings.json file.

Create the document model

Now that the service is set up, you can create a data model for your collection.

In the Models folder, create a new file named Playlist.cs and add the following code:

using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;
using System.Text.Json.Serialization;
namespace MongoExample.Models;
public class Playlist {
    [BsonId]
    [BsonRepresentation(BsonType.ObjectId)]
    public string? Id { get; set; }
    public string username { get; set; } = null!;
    [BsonElement("items")]
    [JsonPropertyName("items")]
    public List<string> movieIds { get; set; } = null!;
}

In the preceding code, the Id field is represented as an ObjectId in BSON and the _id fild within MongoDB. When you work with this locally in your application, it is a string.

The movieIds field will be known as items. When sending or receiving JSON, the field will also be known as items instead of movieIds.

If you plan to have your local class field match the document field directly, it isn't necessary to define custom mappings. For example, the username field in the preceding code has no custom mappings. It will be username in C#, in JSON, and in MongoDB.

Create a controller

In your project, create a folder named Controllers. In the Controllers folder, create a new file named PlaylistController.cs and add the following code:

using System;
using Microsoft.AspNetCore.Mvc;
using MongoExample.Services;
using MongoExample.Models;
namespace MongoExample.Controllers; 
[Controller]
[Route("api/[controller]")]
public class PlaylistController: Controller {
    
    private readonly MongoDBService _mongoDBService;
    public PlaylistController(MongoDBService mongoDBService) {
        _mongoDBService = mongoDBService;
    }
    [HttpGet]
    public async Task<List<Playlist>> Get() {}
    [HttpPost]
    public async Task<IActionResult> Post([FromBody] Playlist playlist) {}
    [HttpPut("{id}")]
    public async Task<IActionResult> AddToPlaylist(string id, [FromBody] string movieId) {}
    [HttpDelete("{id}")]
    public async Task<IActionResult> Delete(string id) {}
}

The PlaylistController class contains a constructor method that gains access to your singleton service class. Then, there is a series of endpoints for this controller.

Add data through the POST endpoint

Go to Services/MongoDBService.cs and update the CreateAsync function to use the following code:

public async Task CreateAsync(Playlist playlist) { 
  await _playlistCollection.InsertOneAsync(playlist);
  return;
}

The preceding code sets the _playlistCollection in the constructor method of the service. This lets your application use the InsertOneAsync method, which takes a passed Playlist variable and inserts it.

To complete the creation of the POST endpoint, go to the Controllers/PlaylistController.cs file and update the Post method to use the following code:

[HttpPost]
public async Task<IActionResult> Post([FromBody] Playlist playlist) {
  await _mongoDBService.CreateAsync(playlist);
  return CreatedAtAction(nameof(Get), new { id = playlist.Id }, playlist);
}

When the POST endpoint executes, the application takes the Playlist object from the request, which .NET Core parses, and passes it to the CreateAsync function in the service. After the insert, the code returns some information about the interaction.

Read data through the GET endpoint

Go to Services/MongoDBService.cs and update the GetAsync function to use the following code:

public async Task<List<Playlist>> GetAsync() { 
  return await _playlistCollection.Find(new BsonDocument()).ToListAsync();
}

The Find operation in the preceding code returns all documents that exist in the collection.

To complete the creation of the GET endpoint, go to the Controllers/PlaylistController.cs file and update the Get method to use the following code:

[HttpGet]
public async Task<List<Playlist>> Get() {
  return await _mongoDBService.GetAsync();
}

Update data using the PUT endpoint

Go to Services/MongoDBService.cs and update the AddToPlaylistAsync function to use the following code:

public async Task AddToPlaylistAsync(string id, string movieId) {
  FilterDefinition<Playlist> filter = Builders<Playlist>.Filter.Eq("Id", id);
  UpdateDefinition<Playlist> update = Builders<Playlist>.Update.AddToSet<string>("movieIds", movieId);
  await _playlistCollection.UpdateOneAsync(filter, update);
  return;
}

The preceding code sets up a match filter to determine which document or documents receive an update, in this case adding an item to your playlist. The code matches based on the Id field, which is unique. Then, the code defines the update critera, which is an AddtoSet operation that only adds an item to the array if it doesn't already exist in the array.

The UpdateOneAsync methods only updates on document even if the match filter returns more than one match.

To complete the creation of the PUT endpoint, go to the Controllers/PlaylistController.cs file and update the AddToPlaylist function to use the following code:

[HttpPut("{id}")]
public async Task<IActionResult> AddToPlaylist(string id, [FromBody] string movieId) {    
  await _mongoDBService.AddToPlaylistAsync(id, movieId);
  return NoContent();
}

Delete data by using the DELETE endpoint

Go to Services/MongoDBService.cs and update the DeleteAsync function to use the following code:

public async Task DeleteAsync(string id) {
  FilterDefinition<Playlist> filter = Builders<Playlist>.Filter.Eq("Id", id);
  await _playlistCollection.DeleteOneAsync(filter);
  return;
}

The preceding code deletes a single document based on the filter criteria, which matches the unique value of the Id field.

To complete the creation of the DELETE endpoint, go to the Controllers/PlaylistController.cs file and update the Delete function to use the following code:

[HttpDelete("{id}")]
public async Task<IActionResult> Delete(string id) {
  await _mongoDBService.DeleteAsync(id);
  return NoContent();
}