Tutorial: Crear una API RESTful mediante el controlador .NET/C#

Crear la clase MongoDBSettings

Su servicio de MongoDB es responsable de establecer una conexión y trabajar directamente con documentos dentro de MongoDB. En su proyecto, cree una carpeta llamada Models. En la carpeta Models, crear un nuevo archivo llamado MongoDBSettings.cs. En este archivo, agregue el siguiente 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!;
}

El código anterior define una clase llamada MongoDBSettings que contiene información sobre su conexión, el nombre de la base de datos y el nombre de la colección.

Actualizar el archivo appsettings.json

Puede encontrar los datos almacenados en los campos de clase definidos en la clase MongoDBSettings en el archivo appsettings.json de los proyectos. Abra este archivo y agregue la siguiente configuración:

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

Este tutorial utiliza la sample_mflix base de datos y la playlist colección. Reemplace el marcador <Atlas connection string> con su cadena de conexión de MongoDB Atlas. Para obtener más información sobre cómo encontrar su cadena de conexión, consulte el tutorial "Conectarse a su clúster" en la documentación de Atlas.

Crear el servicio

En tu proyecto, crea una carpeta llamada Services. En la carpeta Services, crea un archivo llamado MongoDBService.cs y añade el siguiente 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) { }
}

El código anterior define una clase llamada MongoDBService que incluye funciones asíncronas vacías. A lo largo de este tutorial, añadirá código a estas funciones al crear sus endpoints. Las opciones configuradas en el archivo appsettings.json se configuran como variables.

Conectar el servicio a la aplicación

Abre el archivo Program.cs y añade el siguiente código en la parte superior del archivo:

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

En el código anterior, la función GetSection() extrae su configuración del campo MongoDB en el archivo appsettings.json.

Crear el modelo de documento

Ahora que el servicio está configurado, puede crear un modelo de datos para su colección.

En la carpeta Models, cree un nuevo archivo llamado Playlist.cs y agregue el siguiente 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!;
}

En el código anterior, el campo Id se serializa como un ObjectId en el campo _id. El campo se representa como una cadena en la aplicación.

El campo movieIds se serializa como items. Al enviar o recibir valores JSON, el campo también se llama items en lugar de movieIds.

Si planea que su campo de clase local coincida directamente con el campo de documento, no es necesario definir asignaciones personalizadas. Por ejemplo, el campo username del código anterior no tiene asignaciones personalizadas. Se denomina username en C#, JSON y MongoDB.

Crear un controlador

En tu proyecto, crea una carpeta llamada Controllers. En la carpeta Controllers, crea un archivo llamado PlaylistController.cs y añade el siguiente 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) {}
}

La clase PlaylistController contiene un método constructor que accede a la clase de servicio singleton. Además, existen una serie de puntos finales para este controlador.

Agregar datos a través del punto final POST

Vaya a Services/MongoDBService.cs y actualice la función CreateAsync para usar el siguiente código:

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

El código anterior establece la _playlistCollection en el método constructor del servicio. Esto le permite a su aplicación utilizar el método InsertOneAsync, que toma una variable Playlist transmitida e inserta.

Para completar la creación del punto final POST, vaya al archivo Controllers/PlaylistController.cs y actualice el método Post para usar el siguiente código:

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

Cuando se ejecuta el punto de conexión POST, la aplicación toma el objeto Playlist de request, que .NET Core analiza, y lo pasa a la función CreateAsync del servicio. Tras la inserción, el código devuelve información sobre la interacción.

Leer datos a través del punto final GET

Vaya a Services/MongoDBService.cs y actualice la función GetAsync para usar el siguiente código:

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

La operación Find en el código anterior devuelve todos los documentos que existen en la colección.

Para completar la creación del punto final GET, vaya al archivo Controllers/PlaylistController.cs y actualice el método Get para usar el siguiente código:

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

Actualizar datos usando el endpoint PUT

Vaya a Services/MongoDBService.cs y actualice la función AddToPlaylistAsync para usar el siguiente 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;
}

El código anterior configura un filtro de coincidencia para determinar qué documento o documentos se actualizan; en este caso, se agrega un elemento a la lista de reproducción. El código busca coincidencias según el campo Id, que es único. A continuación, define los criterios de actualización, que son una operación AddtoSet que solo agrega un elemento a la matriz si aún no existe.

Los métodos UpdateOneAsync solo se actualizan en el documento incluso si el filtro de coincidencia devuelve más de una coincidencia.

Para completar la creación del punto final PUT, vaya al archivo Controllers/PlaylistController.cs y actualice la función AddToPlaylist para usar el siguiente código:

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

Eliminar datos mediante el punto final DELETE

Vaya a Services/MongoDBService.cs y actualice la función DeleteAsync para usar el siguiente código:

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

El código anterior elimina un solo documento según los criterios de filtro que coinciden con el valor único del campo Id.

Para completar la creación del punto final DELETE, vaya al archivo Controllers/PlaylistController.cs y actualice la función Delete para usar el siguiente código:

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