/ /

/ /

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á cómo integrar OData con su 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, consulte Introducción al controlador .NET/C#.

Tutorial

Instalar dependencias

Cree una nueva aplicación ASP.Net llamada ODataExample e instale el controlador .NET/C#. Puede instalar el controlador mediante el administrador de paquetes NuGet en su IDE o ejecutando el siguiente comando en la 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.

Crear un controlador OData

Cree una carpeta nueva en su solución llamada Controllers y agregue un archivo de controlador llamado RestaurantsController.cs. Copie 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 punto final Get que devuelve todos los restaurantes de la colección.
Especifica el atributo MongoEnableQuery para habilitar la consulta en el punto final Get.
Especifica el atributo PageSize en MongoEnableQuery para limitar la cantidad de documentos devueltos a 5.

Configurar 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 de un nuevo MongoClient y lo registra como un singleton en el contenedor de inyección de dependencia.
Define el modelo de datos de entidad (EDM) y registra Restaurants como un conjunto de entidades con la clave Id.
Agrega el servicio OData y habilita la operación de consulta Select().
Registra la ruta utilizando el método AddRouteComponents().
Llama a los métodos UseRouting() y MapControllers() para hacer coincidir las solicitudes HTTP entrantes y enrutarlas al punto final apropiado.

Nota

El controlador .NET/C# no admite la agregación de OData con la operación de consulta $apply.

Ejecutar la aplicación

Ejecute la aplicación utilizando 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, su 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

Tras ejecutar la aplicación, es posible que el IDE abra automáticamente una ventana del navegador en la URL donde se ejecuta, lo que muestra un error "page can't be found". Esto es normal, ya que la aplicación solo tiene configurado un punto final Get.

Consultar los datos

Para consultar los datos, diríjase al punto final Get especificado en la aplicación. Para ello, abra un navegador y diríjase a la URL localhost especificada en la salida del terminal del paso anterior. A continuación, añada la ruta para el punto final Get: /odata/Restaurants. Por ejemplo, si una aplicación se ejecuta en localhost:5183, diríjase a http://localhost:5183/odata/Restaurants.

Si la operación es correcta, el navegador muestra 5 restaurantes de 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, consulte la documentación de Microsoft OData.

Para obtener más información sobre OData, consulte la documentación de OData.

Volver

Integrations

Referencia rápida