Tutorial: Criar uma API RESTful usando o driver .NET/C#

Criar a classe MongoDBSettings

Seu serviço MongoDB é responsável por estabelecer uma conexão e trabalhar diretamente com documentos no MongoDB. No seu projeto, crie uma pasta denominada Models. Na pasta Models, crie um novo arquivo denominado MongoDBSettings.cs. Neste arquivo, adicione o seguinte código:

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

O código anterior define uma classe chamada MongoDBSettings que contém informações sobre sua conexão, o nome do banco de dados e o nome da collection.

Atualize o arquivo appsettings.json

Você pode encontrar os dados armazenados nos campos de classe definidos na classe MongoDBSettings no arquivo appsettings.json dos projetos. Abra este arquivo e adicione a seguinte configuração:

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

Este tutorial utiliza o banco de dados sample_mflix e a collection playlist. Substitua o espaço reservado <Atlas connection string> pela string de conexão do MongoDB Atlas. Para mais informações sobre como localizar sua string de conexão, consulte o tutorial Connect to Your Cluster na documentação do Atlas.

Criar o serviço

No seu projeto, crie uma pasta denominada Services. Na pasta Services, crie um novo arquivo denominado MongoDBService.cs e adicione o seguinte código:

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) { }
}

O código anterior define uma classe denominada MongoDBService que inclui funções assíncronas vazias. Ao longo deste tutorial, você adiciona código a essas funções à medida que cria seus endpoints. As configurações que você configurou no arquivo appsettings.json estão definidas para variáveis.

Conecte o serviço ao aplicação

Abra o arquivo Program.cs e adicione o seguinte código ao topo do arquivo:

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

No código anterior, a função GetSection() extrai suas configurações do campo MongoDB no arquivo appsettings.json.

Criar o modelo de documento

Agora que o serviço está configurado, você pode criar um modelo de dados para a sua collection.

Na pasta Models, crie um novo arquivo denominado Playlist.cs e adicione o seguinte código:

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!;
}

No código anterior, o campo Id é serializado como ObjectId no campo _id. O campo é representado como uma string em seu aplicação.

O campo movieIds é serializado como items. Quando você envia ou recebe valores JSON, o campo também é nomeado items em vez de movieIds.

Se você planeja que seu campo de classe local corresponda diretamente ao campo do documento , não é necessário definir mapeamentos personalizados. Por exemplo, o campo username no código anterior não tem mapeamentos personalizados. É chamado username em C#, em JSON e em MongoDB.

Criar um controlador

No seu projeto, crie uma pasta denominada Controllers. Na pasta Controllers, crie um novo arquivo denominado PlaylistController.cs e adicione o seguinte código:

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) {}
}

A classe PlaylistController contém um método de construtor que obtém acesso à sua classe de serviço singleton. Depois, há uma série de endpoints para esse controlador.

Adicionar dados por meio do endpoint POST

Vá para Services/MongoDBService.cs e atualize a função CreateAsync para utilizar o seguinte código:

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

O código anterior define o _playlistCollection no método construtor do serviço. Isso permite que seu aplicação use o método InsertOneAsync, que usa uma variável Playlist passada e a insere.

Para concluir a criação do endpoint POST , vá para o arquivo Controllers/PlaylistController.cs e atualize o método Post para utilizar o seguinte código:

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

Quando o endpoint POST é executado, o aplicação pega o objeto Playlist do request, que o .NET Core analisa, e o passa para a função CreateAsync no serviço. Após a inserção, o código retorna informações sobre a interação.

Ler dados por meio do endpoint GET

Vá para Services/MongoDBService.cs e atualize a função GetAsync para utilizar o seguinte código:

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

A operação Find no código anterior retorna todos os documentos existentes na coleção.

Para concluir a criação do endpoint GET , vá para o arquivo Controllers/PlaylistController.cs e atualize o método Get para utilizar o seguinte código:

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

Atualizar dados usando o endpoint PUT

Vá para Services/MongoDBService.cs e atualize a função AddToPlaylistAsync para utilizar o seguinte código:

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;
}

O código anterior define um filtro de correspondência para determinar quais documento recebem uma atualização, neste caso, adicionar um item à sua lista de reprodução. O código corresponde com base no campo Id , que é único. Em seguida, o código define os critérios de atualização, que é uma operação AddtoSet que só adiciona um item à array se ele ainda não existir na array.

Os métodos UpdateOneAsync só atualizam no documento mesmo que o filtro de correspondência retorne mais de uma correspondência.

Para concluir a criação do ponto de extremidade PUT, acesse o arquivo Controllers/PlaylistController.cs e atualize a função AddToPlaylist para usar o seguinte código:

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

Excluir dados usando o endpoint DELETE

Vá para Services/MongoDBService.cs e atualize a função DeleteAsync para utilizar o seguinte código:

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

O código anterior exclui um único documento com base nos critérios de filtro, que corresponde ao valor exclusivo do campo Id.

Para concluir a criação do endpoint DELETE, vá para o arquivo Controllers/PlaylistController.cs e atualize a função Delete para utilizar o seguinte código:

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