Create a RESTful API with .NET Core and MongoDB
Rate this tutorial
If you've been keeping up with my development content, you'll remember that I recently wrote , which focused on building a console application that integrated with MongoDB. While there is a fit for MongoDB in console applications, many developers are going to find it more valuable in web applications.
In this tutorial, we're going to expand upon the previous and create a RESTful API with endpoints that perform basic create, read, update, and delete (CRUD) operations against MongoDB Atlas.
To be successful with this tutorial, you'll need to have a few things taken care of first:
- A deployed and configured MongoDB Atlas cluster, M0 or higher
- .NET Core 6+
We'll be using .NET Core 6.0 in this tutorial, but other versions may still work. Just take the version into consideration before continuing.
To kick things off, we're going to create a fresh .NET Core project using the web application template that Microsoft offers. To do this, execute the following commands from the CLI:
The above commands will create a new web application project for .NET Core and install the latest MongoDB driver. We'll be left with some boilerplate files as part of the template, but we can remove them.
Inside the project, delete any file related to
Before we start designing each of the RESTful API endpoints with .NET Core, we need to create and configure our MongoDB service and define the data model for our API.
We'll start by working on our MongoDB service, which will be responsible for establishing our connection and directly working with documents within MongoDB. Within the project, create "Models/MongoDBSettings.cs" and add the following C# code:
MongoDBSettingsclass will hold information about our connection, the database name, and the collection name. The data we plan to store in these class fields will be found in the project's "appsettings.json" file. Open it and add the following:
With the settings in place, we can move onto creating the service.
Create "Services/MongoDBService.cs" within your project and add the following:
In the above code, each of the asynchronous functions were left blank on purpose. We'll be populating those functions as we create our endpoints. Instead, make note of the constructor method and how we're taking the passed settings that we saw in our "appsettings.json" file and setting them to variables. In the end, the only variable we'll ever interact with for this example is the
With the service available, we need to connect it to the application. Open the project's "Program.cs" file and add the following at the top:
You'll likely already have the
buildervariable in your code because it was part of the boilerplate project, so don't add it twice. What you'll need to add near the top is an import to your custom models and services as well as configuring the service.
MongoDBfield in the "appsettings.json" file? That is the section that the
GetSectionfunction is pulling from. That information is passed into the singleton service that we created.
With the service created and working, with the exception of the incomplete asynchronous functions, we can focus on creating a data model for our collection.
Create "Models/Playlist.cs" and add the following C# code:
There are a few things happening in the above class that take it from a standard C# class to something that can integrate seamlessly into a MongoDB document.
First, you might notice the following:
We're saying that the
Idfield is to be represented as an ObjectId in BSON and the
_idfield within MongoDB. However, when we work with it locally in our application, it will be a string.
The next thing you'll notice is the following:
Even though we plan to work with
movieIdswithin our C# application, in MongoDB, the field will be known as
itemsand when sending or receiving JSON, the field will also be known as
You don't need to define custom mappings if you plan to have your local class field match the document field directly. Take the
usernamefield in our example. It has no custom mappings, so it will be
usernamein JSON, and
Just like that, we have a MongoDB service and document model for our collection to work with for .NET Core.
When building CRUD endpoints for this project, we'll need to bounce between two different locations within our project. We'll need to define the endpoint within a controller and do the work within our service.
Create "Controllers/PlaylistController.cs" and add the following code:
In the above
PlaylistControllerclass, we have a constructor method that gains access to our singleton service class. Then we have a series of endpoints for this particular controller. We could add far more endpoints than this to our controller, but it's not necessary for this example.
Let's start with creating data through the POST endpoint. To do this, it's best to start in the "Services/MongoDBService.cs" file:
We had set the
_playlistCollectionin the constructor method of the service, so we can now use the
InsertOneAsyncmethod, taking a passed
Playlistvariable and inserting it. Jumping back into the "Controllers/PlaylistController.cs," we can add the following:
What we're saying is that when the endpoint is executed, we take the
Playlistobject from the request, something that .NET Core parses for us, and pass it to the
CreateAsyncfunction that we saw in the service. After the insert, we return some information about the interaction.
It's important to note that in this example project, we won't be validating any data flowing from HTTP requests.
Let's jump to the read operations.
Head back into the "Services/MongoDBService.cs" file and add the following function:
Findoperation will return all documents that exist in the collection. If you wanted to, you could make use of the
FindOneor provide filter criteria to return only the data that you want. We'll explore filters shortly.
With the service function ready, add the following endpoint to the "Controllers/PlaylistController.cs" file:
Not so bad, right? We'll be doing the same thing for the other endpoints, more or less.
The next CRUD stage to take care of is the updating of data. Within the "Services/MongoDBService.cs" file, add the following function:
Rather than making changes to the entire document, we're planning on adding an item to our playlist and nothing more. To do this, we set up a match filter to determine which document or documents should receive the update. In this case, we're matching on the id which is going to be unique. Next, we're defining the update criteria, which is an
AddToSetoperation that will only add an item to the array if it doesn't already exist in the array.
UpdateOneAsyncmethod will only update one document even if the match filter returned more than one match.
In the "Controllers/PlaylistController.cs" file, add the following endpoint to pair with the
In the above PUT endpoint, we are taking the
idfrom the route parameters and the
movieIdfrom the request body and using them with the
This brings us to our final part of the CRUD spectrum. We're going to handle deleting of data.
In the "Services/MongoDBService.cs" file, add the following function:
The above function will delete a single document based on the filter criteria. The filter criteria, in this circumstance, is a match on the id which is always going to be unique. Your filters could be more extravagant if you wanted.
To bring it to an end, the endpoint for this function would look like the following in the "Controllers/PlaylistController.cs" file:
We only created four endpoints, but you could take everything we did and create 100 more if you wanted to. They would all use a similar strategy and can leverage everything that MongoDB has to offer.
Like I mentioned, you can take the same strategy used here and apply it towards more endpoints, each doing something critical for your web application.