/ /

/ /

Librerías de clientes

Driver C#/.NET

Integrations

Usa OData con MongoDB

Overview

OData (Open Data Protocol) es un protocolo estandarizado para construir y consumir APIs RESTful que permite consultar y manipular datos mediante solicitudes HTTP. Proporciona una forma uniforme de exponer e interactuar con datos de múltiples fuentes.

En este tutorial, aprenderás cómo integrar OData con tu aplicación MongoDB.

Datos de muestra

Este tutorial utiliza el sample_restaurants.restaurants colección de la Conjuntos de datos de muestra de Atlas. Para aprender a crear un clúster gratuito de MongoDB Atlas y cargar los conjuntos de datos de muestra, consulta el Comience con el controlador .NET/C#.

Tutorial

Instale las dependencias

Crea una aplicación nueva de ASP.Net llamada ODataExample e instala el controlador .NET/C#. Puedes instalar el driver usando el gestor de paquetes NuGet en tu IDE, o ejecutando el siguiente comando en el CLI de .NET:

dotnet add package MongoDB.Driver

Luego, instala el paquete NuGet MongoDB.AspNetCore.OData a través del Administrador de Paquetes NuGet o mediante la CLI de .NET ejecutando el siguiente comando:

dotnet add package MongoDB.AspNetCore.OData

Define tus Modelos

Crea una nueva carpeta en tu solución llamada Models y copia los siguientes archivos Restaurant.cs, Address.cs y GradeEntry.cs en la carpeta:

public class Restaurant
{
    [BsonRepresentation(BsonType.ObjectId)]
    public string Id { get; set; }
    public string Name { get; set; }
    [BsonElement("restaurant_id")]
    public string RestaurantId { get; set; }
    public string Cuisine { get; set; }
    public Address Address { get; set; }
    public string Borough { get; set; }
    public List<GradeEntry> Grades { get; set; }
}

public class Address
{
    public string Building { get; set; }
    [BsonElement("coord")]
    public double[] Coordinates { get; set; }
    public string Street { get; set; }
    [BsonElement("zipcode")]
    public string ZipCode { get; set; }
}

public class GradeEntry
{
    public DateTime Date { get; set; }
    public string Grade { get; set; }
    public float? Score { get; set; }
}

Nota

Los documentos de la colección restaurants utilizan la convención de nomenclatura snake-case. Los ejemplos de esta guía utilizan un ConventionPack para deserializar los campos de la colección en notación Pascal y asignarlos a las propiedades de la clase Restaurant.

Para aprender más sobre la serialización personalizada, consultar Serialización personalizada.

Crea un controlador OData

Crea una nueva carpeta en tu solución llamada Controllers y añade un nuevo archivo de controlador denominado RestaurantsController.cs. Copia el siguiente código en el archivo:

using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.OData.Routing.Controllers;
using MongoDB.AspNetCore.OData;
using MongoDB.Driver;
using ODataTest.Models;
namespace ODataTest.Controllers;
public class RestaurantsController : ODataController
{
    private readonly IQueryable<Restaurant> _restaurants;
    public RestaurantsController(IMongoClient client)
    {
        var database = client.GetDatabase("sample_restaurants");
        _restaurants = database.GetCollection<Restaurant>("restaurants")
            .AsQueryable();
    }
    // Registers Get endpoint and sets max documents to 5
    [MongoEnableQuery(PageSize = 5)]
    public ActionResult<IEnumerable<Restaurant>> Get()
    {
        return Ok(_restaurants);
    }
}

Este código realiza las siguientes acciones:

Crea un constructor que se conecta a MongoDB y obtiene la colección restaurants.
Crea un endpoint Get que devuelve todos los restaurantes de la colección.
Especifica el atributo MongoEnableQuery para habilitar consultas en el extremo Get.
Especifica el atributo PageSize en MongoEnableQuery para limitar el número de documentos devueltos a 5.

Configura el servicio OData

Pega el siguiente código en tu archivo Program.cs para configurar el servicio OData y mapear los endpoints de tu controlador.

using Microsoft.AspNetCore.OData;
using Microsoft.OData.ModelBuilder;
using MongoDB.Bson.Serialization.Conventions;
using MongoDB.Driver;
using ODataTest.Models;
var builder = WebApplication.CreateBuilder(args);
// Registers a convention pack to convert fields to camel case
var camelCaseConvention = new ConventionPack {
        new CamelCaseElementNameConvention()
    };
ConventionRegistry.Register(
    "CamelCase", camelCaseConvention, type => true);
builder.Services.AddSingleton<IMongoClient>(
    new MongoClient("<Your connection URI>"));
// Registers the Restaurants entity and sets the Id field as the key
var modelBuilder = new ODataConventionModelBuilder();
modelBuilder.EntitySet<Restaurant>("Restaurants");
modelBuilder.EntityType<Restaurant>().HasKey(r => r.Id);
// Adds OData and specify query capabilities
builder.Services.AddControllers().AddOData(
    options => options.Select()
        .AddRouteComponents("odata", modelBuilder.GetEdmModel())
);
var app = builder.Build();
app.UseRouting();
app.MapControllers();
app.Run();

Nota

Reemplace el marcador de posición <"Your connection URI"> con su cadena de conexión a MongoDB.

Este código realiza las siguientes acciones:

Crea una instancia nueva de MongoClient y lo registra como singleton en el contenedor de inyección de dependencias.
Define el Modelo de Datos de Entidad (EDM) y registra a Restaurants como un conjunto de entidades con la clave Id.
Agrega el servicio OData y habilita la operación de query Select().
Registra la ruta usando el método AddRouteComponents().
Llama a los métodos UseRouting() y MapControllers() para hacer coincidir las solicitudes HTTP entrantes y enrutarías al endpoint correspondiente.

Nota

El driver .NET/C# no es compatible con la agregación OData con la operación de query $apply.

Ejecutar la aplicación

Ejecute la aplicación usando su IDE o ejecutando el siguiente comando en su shell en el directorio raíz de su proyecto:

dotnet run ODataExample.csproj

Después de ejecutar la aplicación, tu terminal muestra una salida similar a la siguiente:

info: Microsoft.Hosting.Lifetime[14]
      Now listening on: http://localhost:5183
info: Microsoft.Hosting.Lifetime[0]
      Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
      Hosting environment: Development
info: Microsoft.Hosting.Lifetime[0]
      Content root path: <Path to your project>

Tip

Después de ejecutar tu aplicación, es posible que tu IDE abra automáticamente una ventana del navegador con la URL donde está funcionando la aplicación, la cual muestra un error "page can't be found". Esto es esperado porque la aplicación solo tiene un punto final Get configurado.

Query los datos

Para consultar los datos, dirígete al extremo Get especificado en la aplicación. Para ello, abre un navegador y navega a la URL localhost especificada en la salida del terminal del paso anterior. A continuación, añade la ruta para el endpoint Get: /odata/Restaurants. Por ejemplo, si una aplicación se está ejecutando en localhost:5183, navega hasta http://localhost:5183/odata/Restaurants.

Si se tiene éxito, el navegador muestra 5 restaurantes en la colección, en formato JSON. El resultado es similar al siguiente:

{
  "@odata.context": "http://localhost:5183/odata/$metadata#Restaurants",
  "value": [
    {
      "Name": "Glorious Food",
      "RestaurantId": "40361521",
      "Cuisine": "American",
      "Borough": "Manhattan",
      "Id": "...",
      "Address": {
        "Building": "522",
        "Coordinates": [-73.95171, 40.767461],
        "Street": "East   74 Street",
        "ZipCode": "10021"
      },
      "Grades": [
        ...
      ]
    },
    ...
    ]
}

Información Adicional

Para obtener más información sobre ASP.NET Core OData, consulta la documentación de Microsoft OData.

Para aprender más información sobre OData, consulta la documentación de OData.

Volver

Integrations

Referencia rápida