Forem: Patrick Tshibanda

How to create a Web API with ASP.NET and MongoDB

Patrick Tshibanda — Sun, 19 Dec 2021 20:11:55 +0000

In this tutorial, you will learn how to create a Web API with ASP.NET and MongoDB. We will create an API that allows CRUD operations on a movie database.

What is MongoDB?

MongoDB is a document-based NoSQL database. Unlike a relational database, which stores data in tables, MongoDB stores data as documents that are organized into collections.

Tools

Creating the database

I’m going to work with MongoDB on my local computer. To install an instance of the MongoDB server follow the link below.

Install MongoDB

If you don't want to use MongoDB on your local machine, you can always use MongoDB Atlas. MongoDB Atlas is a database as a service, and you can try it for free.

Launch MongoDB Compass.
Click on the "Connect" button to connect to your local server.
Once connected to the server, click on the Create Database button to create a new database.
In the dialog, set the database name to MoviesDb and set the collection name to MoviesCollection.
Click on Create Database button to generate the database.

Creating the ASP.NET Application

Launch Visual Studio 2022.
Go to file -> new -> Project.
Select ASP.NET Empty template, then click on the Next button.
Set the project's name to MoviesAPI.
Select .NET 6 as the framework and unselect configure with HTTPS then click on the Create button to generate the project.

Installing the MongoDB .NET driver

This is the official .NET driver for MongoDB, it will help connect to MongoDB.

Open the NuGet Package Manager UI in Visual Studio.
Search for MongoDB.Driver, select and install.

Configuration

To connect to MongoDB, we will need some details like the connection string, the database name, and the collection name. We will store these details in the application configuration file.
```
"MoviesDatabaseSettings": {
  "ConnectionString": "Your connection string to MongoDB",
  "DatabaseName": "MoviesDb",
  "MoviesCollectionName": "Movies"
}
```

💡 To get the connection string for your database, disconnect from MongoDB Compass, and the connection string will be displayed on the home window of the application.

To read this section in the application, we will use the options pattern. Add a new class named MoviesDatabaseSettings.

public class MoviesDatabaseSettings
{
    public string ConnectionString { get; set; } = string.Empty;
    public string DatabaseName { get; set; } = string.Empty;
    public string MoviesCollectionName { get; set; } = string.Empty;
}

ASP.NET will map the section "MoviesDatabaseSettings" to this class.

In program.cs, after a WebApplication is instantiated, we register the MoviesDatabaseSettings class with the dependency injection container.
```
builder.Services.Configure<MoviesDatabaseSettings>(builder.Configuration.GetSection("MoviesDatabaseSettings"));
```
Make sure, you install the following Nuget package: Microsoft.Extensions.Options

Creating the model

Add a new class like the one below:

 public class Movie
 {
     [BsonId]
     [BsonRepresentation(MongoDB.Bson.BsonType.ObjectId)]
     public string Id { get; set; }
     public string Title { get; set; }
     public int Year { get; set; }
     public string Summary { get; set; } = null;
     public List<string> Actors { get; set; }
 }

The Id property is decorated with the BsonId attribute to mark it as the primary key.
MongoDB stores the primary key in an ObjectId structure, to tell MongoDB that it needs to convert from string to ObjectId, the Id property is also decorated with the attribute BsonRepresentation.

Creating CRUD operations in a service

Add a new class, paste the following code:

public class MoviesService
{
    private readonly IMongoCollection<Movie> _movies;

    public MoviesService(IOptions<MoviesDatabaseSettings> options)
    {
        var mongoClient = new MongoClient(options.Value.ConnectionString);

        _movies = mongoClient.GetDatabase(options.Value.DatabaseName)
            .GetCollection<Movie>(options.Value.MoviesCollectionName);
    }

    public async Task<List<Movie>> Get() =>
        await _movies.Find(_ => true).ToListAsync();

    public async Task<Movie> Get(string id) =>
        await _movies.Find(m => m.Id == id).FirstOrDefaultAsync();

    public async Task Create(Movie newMovie) =>
        await _movies.InsertOneAsync(newMovie);

    public async Task Update(string id, Movie updateMovie) =>
        await _movies.ReplaceOneAsync(m => m.Id == id, updateMovie);

    public async Task Remove(string id) =>
        await _movies.DeleteOneAsync(m => m.Id == id);
}

MongoClient is responsible for running database operations.

Register the service with the dependency injection container.
```
builder.Services.AddSingleton<MoviesService>();
```
MoviesService is registered as a singleton because the service depends on the MongoClient, it is recommended to use the MongoClient as a singleton.

Creating endpoints for CRUD operations

Update the program.cs to look like this:

using MoviesAPI.Data;

var builder = WebApplication.CreateBuilder(args);
builder.Services.Configure<MoviesDatabaseSettings>(builder.Configuration.GetSection("MoviesDatabaseSettings"));
builder.Services.AddSingleton<MoviesService>();
var app = builder.Build();

app.MapGet("/", () => "Movies API!");

app.MapGet("/api/movies", async(MoviesService moviesService) => await moviesService.Get());

app.MapGet("/api/movies/{id}", async(MoviesService moviesService, string id) =>
{
    var movie = await moviesService.Get(id);
    return movie is null ? Results.NotFound() : Results.Ok(movie);
});

app.MapPost("/api/movies", async (MoviesService moviesService, Movie movie) =>
{
    await moviesService.Create(movie);
    return Results.Ok();
});

app.MapPut("/api/movies/{id}", async(MoviesService moviesService, string id, Movie updatedMovie) =>
{
    var movie = await moviesService.Get(id);
    if (movie is null) return Results.NotFound();

    updatedMovie.Id = movie.Id;
    await moviesService.Update(id, updatedMovie);

    return Results.NoContent();
});

app.MapDelete("/api/movies/{id}", async (MoviesService moviesService, string id) =>
{
    var movie = await moviesService.Get(id);
    if (movie is null) return Results.NotFound();

    await moviesService.Remove(movie.Id);

    return Results.NoContent();
});

app.Run();

Creating, Reading, Updating, and deleting actions will be mapped to HTTP verbs such as POST, GET, PUT, and DELETE.
I am using the Minimal API syntax to create each endpoint. For an HTTP verb, We need to declare a route and a route handler that will handle a request to the route. Because we registered the MoviesService with the dependency injection container, it can be injected in each route handler.

Testing the API

If you want to add a new movie for instance.

Start Debugging the application or press F5.
Copy the URL displayed in the web browser.
Launch POSTMAN.
Create a new request then select POST as HTTP verb.
In the address bar, paste the URL then add "/api/movies".
In the Body section, paste the following json as the payload.

    {
        "Title":  "The Shawshank Redemption",
        "Year":  1994,
        "Summary":  "Banker Andy Dufresne is arrested for killing his wife and her lover. After a hard adjustment, he tries to improve the conditions of the prison and to give hope to his companions.",
        "Actors":  ["tim robbins","morgan freeman"]
    }

Click on the SEND button.
You should get a 200 status code as the response.

Happy coding !!!

Here's the tutorial in video:

How to use Git with Visual Studio

Patrick Tshibanda — Fri, 10 Dec 2021 15:13:01 +0000

Git is a version control system commonly used for software development. It offers a number of features such as the ability to merge, split and compare versions.

Visual Studio offers a Git integration that allows developers to access those features without leaving the environment.

In this video, I provide an overview of how to use git in Visual Studio.

I cover the following topics :

Create a GIT repository
Create a branch
Saving changes
Combine multiple commits into one.
Modify the last commit
Push to a remote repository
Fetch, pull, sync a remote repository
Merge
Revert a commit
Go back in time with Reset
Resolve merge conflicts

Watch the video here :

Call an existing Web API with a C# application (VIDEO)

Patrick Tshibanda — Sun, 21 Feb 2021 14:31:07 +0000

This video is about calling an existing WEB API from a C# application.

You will learn to use the HttpClient class to retrieve new releases from Spotify using their Web API.

Repository Pattern with a C# and ASP.NET Core example [VIDEO]

Patrick Tshibanda — Wed, 10 Feb 2021 15:25:36 +0000

The repository pattern helps decouple your code from the data access layer, it promotes reuse and makes your code easy to test.

In this tutorial, you will learn the Repository pattern through an example written with ASP.NET CORE and C#.

If you like the content, feel free to like the video and subscribe to the channel.

Create a Web API with ASP.NET Core. (video)

Patrick Tshibanda — Wed, 27 Jan 2021 15:39:02 +0000

In this video, you will learn how to create a WEB API with ASP.NET CORE and C #.

We will create an API that supports Creating, Reading, Updating, and Deleting Data.

I used the following tools :

Visual Studio 2019
ASP.NET CORE and the .NET 5 SDK
Entity Framework Core
SQLite
Swagger UI

The final code can be found here: https://github.com/estyval/Web-API-With-ASP.NET-Core

If you like the content, feel free to like the video and subscribe to the channel 🙏.

How to code Rock Paper Scissors in the browser with C# (VIDEO)

Patrick Tshibanda — Thu, 24 Dec 2020 09:53:28 +0000

In this video, you will learn to create the Rock-paper-scissors game using Blazor WebAssembly.

You will use HTML, CSS, and C# to create the game.

The source code is available on Github : https://github.com/estyval/RockPaperScissors

If you like the content, feel free to like the video and subscribe to the channel 🙏.

Build your own Music Pad with C#, HTML, and CSS (VIDEO)

Patrick Tshibanda — Wed, 02 Dec 2020 20:50:18 +0000

In this video, I create a simple music pad controller with Blazor WebAssembly.

Blazor is a framework for creating web applications using HTML, CSS, and C# 🔥.

The following topics are cover in the video :

Components
Event handling
CSS isolation
JavaScript interoperability
HTML DOM Audio Object

The source code is available here:https://github.com/estyval/BlazorMusicPad

If you like the content, feel free to like the video and subscribe to the channel 🙏.

Firebase Authentication with Xamarin Forms

Patrick Tshibanda — Sun, 01 Nov 2020 15:40:15 +0000

How to create a BMI calculator with Xamarin Forms.

Patrick Tshibanda — Wed, 29 Jul 2020 20:53:54 +0000

Learn how to create a body mass index calculator using Xamarin Forms and C#.