3 EF Core Integrations That Work with Couchbase

El nuevo EF Proveedor principal abre la puerta a algunas potentes integraciones .NET: incluso aquellas tradicionalmente ligadas a bases de datos relacionales. Este artículo explica cómo funcionan Identity, GraphQL y OData con Couchbase.

En este artículo, repasaré tres integraciones avanzadas de EF Core que he probado con éxito con Couchbase:

1. Identidad ASP.NET Core
2. GraphQL (a través de Hot Chocolate)
3. OData

Nota: Estas integraciones se basan en pruebas limitadas y no cuentan con soporte oficial (todavía). Su kilometraje puede variar, pero hasta ahora, son muy prometedoras.

Identidad ASP.NET Core

Microsoft.AspNetCore.Identity.EntityFrameworkCore proporciona un sistema plug-and-play de autenticación y gestión de usuarios para aplicaciones ASP.NET.

El proveedor EF Core de Couchbase funciona bien con él. La única advertencia es que tendrás que asegurarte de que el archivo primero existen las colecciones adecuadas (como AspNetUsers, AspNetRoles, etc.).

Nota: Debe crear previamente las siguientes colecciones: AspNetUsers, AspNetRoles, AspNetUserRoles, AspNetUserClaims, AspNetUserLogins, AspNetUserTokens, AspNetRoleClaims.

Ejemplo de configuración de EF

public class AppDbContext : IdentityDbContext<ApplicationUser>
{
    public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) { }

    protected override void OnModelCreating(ModelBuilder builder)
    {
        base.OnModelCreating(builder);

        builder.Entity<ApplicationUser>().ToCouchbaseCollection(this, "AspNetUsers");
        builder.Entity<IdentityRole>().ToCouchbaseCollection(this, "AspNetRoles");
        builder.Entity<IdentityUserRole<string>>().ToCouchbaseCollection(this, "AspNetUserRoles");
        builder.Entity<IdentityUserClaim<string>>().ToCouchbaseCollection(this, "AspNetUserClaims");
        builder.Entity<IdentityUserLogin<string>>().ToCouchbaseCollection(this, "AspNetUserLogins");
        builder.Entity<IdentityUserToken<string>>().ToCouchbaseCollection(this, "AspNetUserTokens");
        builder.Entity<IdentityRoleClaim<string>>().ToCouchbaseCollection(this, "AspNetRoleClaims");
    }
}

public class ApplicationUser : IdentityUser { }

público clase AppDbContext : IdentityDbContext<AplicaciónUsuario>

{

público AppDbContext(DbContextOptions<AppDbContext> opciones) : base(opciones) { }

protegido anular void OnModelCreating(ModelBuilder constructor)

{

base.OnModelCreating(constructor);

constructor.Entidad<AplicaciónUsuario>().ToCouchbaseCollection(este, "AspNetUsers");

constructor.Entidad<IdentidadRole>().ToCouchbaseCollection(este, "AspNetRoles");

constructor.Entidad<IdentidadUserRole<cadena>>().ToCouchbaseCollection(este, "AspNetUserRoles");

constructor.Entidad<IdentityUserClaim<cadena>>().ToCouchbaseCollection(este, "AspNetUserClaims");

constructor.Entidad<IdentidadUserLogin<cadena>>().ToCouchbaseCollection(este, "AspNetUserLogins");

constructor.Entidad<IdentityUserToken<cadena>>().ToCouchbaseCollection(este, "AspNetUserTokens");

constructor.Entidad<IdentityRoleClaim<cadena>>().ToCouchbaseCollection(este, "AspNetRoleClaims");

}

público clase AplicaciónUsuario : IdentidadUsuario { }

MVC auth ejemplo

Este es un controlador ASP.NET Core MVC con registro, inicio de sesión y cierre de sesión, así como un rol personalizado:

public class AuthController : Controller
{
    private readonly UserManager<ApplicationUser> _userManager;
    private readonly SignInManager<ApplicationUser> _signInManager;
    private readonly RoleManager<IdentityRole> _roleManager;

    public AuthController(UserManager<ApplicationUser> userManager, SignInManager<ApplicationUser> signInManager, RoleManager<IdentityRole> roleManager)
    {
        _userManager = userManager;
        _signInManager = signInManager;
        _roleManager = roleManager;
    }

    public IActionResult Register() => View();

    [HttpPost]
    public async Task<IActionResult> Register(RegisterModel model)
    {
        if (!ModelState.IsValid) return View(model);

        var user = new ApplicationUser { UserName = model.Email, Email = model.Email };
        var result = await _userManager.CreateAsync(user, model.Password);
        if (result.Succeeded)
        {
            var roleName = "CustomRole";
            if (!await _roleManager.RoleExistsAsync(roleName))
                await _roleManager.CreateAsync(new IdentityRole(roleName));

            await _userManager.AddToRoleAsync(user, roleName);
            await _signInManager.SignInAsync(user, isPersistent: false);
            return RedirectToAction("Index", "Home");
        }

        foreach (var error in result.Errors) ModelState.AddModelError("", error.Description);
        return View(model);
    }

    public IActionResult Login() => View();

    [HttpPost]
    public async Task<IActionResult> Login(LoginModel model)
    {
        if (!ModelState.IsValid) return View(model);

        var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, false, false);
        if (result.Succeeded)
            return RedirectToAction("Index", "Home");

        ModelState.AddModelError("", "Invalid login attempt.");
        return View(model);
    }

    public async Task<IActionResult> Logout()
    {
        await _signInManager.SignOutAsync();
        return RedirectToAction("Index", "Home");
    }
}

público clase AuthController : Controlador

{

privado sólo lectura Gestor de usuarios<AplicaciónUsuario> _userManager;

privado sólo lectura SignInManager<AplicaciónUsuario> _signInManager;

privado sólo lectura Gestor de roles<IdentidadRole> _roleManager;

público AuthController(Gestor de usuarios<AplicaciónUsuario> userManager, SignInManager<AplicaciónUsuario> signInManager, Gestor de roles<IdentidadRole> gestor de funciones)

{

_userManager = userManager;

_signInManager = signInManager;

_roleManager = gestor de funciones;

}

público IActionResult Regístrese en() => Ver();

[HttpPost]

público async Tarea<IActionResult> Regístrese en(RegisterModel modelo)

{

si (!EstadoModelo.IsValid) devolver Ver(modelo);

var usuario = nuevo AplicaciónUsuario { Nombre de usuario = modelo.Correo electrónico, Correo electrónico = modelo.Correo electrónico };

var resultado = await _userManager.CreateAsync(usuario, modelo.Contraseña);

si (resultado.Con éxito)

{

var roleName = "CustomRole";

si (!await _roleManager.RoleExistsAsync(roleName))

await _roleManager.CreateAsync(nuevo IdentidadRole(roleName));

await _userManager.AddToRoleAsync(usuario, roleName);

await _signInManager.SignInAsync(usuario, isPersistent: falso);

devolver RedirectToAction("Índice", "Inicio");

}

foreach (var error en resultado.Errores) EstadoModelo.AddModelError("", error.Descripción);

devolver Ver(modelo);

}

público IActionResult Inicio de sesión() => Ver();

[HttpPost]

público async Tarea<IActionResult> Inicio de sesión(LoginModel modelo)

{

si (!EstadoModelo.IsValid) devolver Ver(modelo);

var resultado = await _signInManager.PasswordSignInAsync(modelo.Correo electrónico, modelo.Contraseña, falso, falso);

si (resultado.Con éxito)

devolver RedirectToAction("Índice", "Inicio");

EstadoModelo.AddModelError("", "Intento de inicio de sesión no válido".);

devolver Ver(modelo);

}

público async Tarea<IActionResult> Cierre de sesión()

{

await _signInManager.SignOutAsync();

devolver RedirectToAction("Índice", "Inicio");

}

Los datos siguen la estructura estándar de Identity, almacenados en un documento Couchbase. Por ejemplo, un documento en AspNetUser colección:

GraphQL con chocolate caliente

Chocolate caliente es un popular servidor GraphQL para .NET. Puede integrarse con EF Core, apoyándose en las capacidades LINQ del proveedor (que tiene Couchbase). Esto significa que las consultas GraphQL se traducen a LINQ, que a su vez se traduce a Couchbase SQL++.

Configurar

public class WidgetQuery
{
    [UseFiltering]
    [UseSorting]
    public IQueryable<Widget> GetWidgets([Service] WidgetDbContext dbContext)
        => dbContext.Widgets;
}

// Program.cs:

builder.Services
    .AddGraphQLServer()
    .AddQueryType<WidgetQuery>()
    .AddFiltering()
    .AddSorting()
    .AddProjections();

app.MapGraphQL();

público clase WidgetQuery

{

[UtilizarFiltrado]

[UtilizarClasificación]

público IQueryable<Widget> GetWidgets([Servicio] WidgetDbContext dbContext)

=> dbContext.Widgets;

}

// Programa.cs:

constructor.Servicios

.AddGraphQLServer()

.AddQueryType<WidgetQuery>()

.Añadir filtro()

.AñadirClasificación()

.AñadirProyecciones();

aplicación.MapGraphQL();

Ejemplo de uso

Ir a /graphql en el navegador (se abre una interfaz web)

Prueba con una consulta como ésta:

query {
  widgets(where: { name: { contains: "foo" } }, order: { createdDt: DESC }) {
    id
    name
    price
    numInStock
    createdDt
  }
}

consulta {

widgets(donde: { nombre: { contiene: "foo" } }, pedir: { creadoDt: DESC }) {

nombre

precio

numInStock

creadoDt

}

Esto devolverá resultados como:

{
  "data": {
    "widgets": [
      {
        "id": "b5c494fe-135f-4f01-bf12-6e4ad1eee829",
        "name": "foobar",
        "price": 1.99,
        "numInStock": 50,
        "createdDt": "2025-06-18T18:11:19.149Z"
      }
    ]
  }
}

{

"datos": {

"widgets": [

{

"id": "b5c494fe-135f-4f01-bf12-6e4ad1eee829",

"nombre": "foobar",

"precio": 1.99,

"numInStock": 50,

"createdDt": "2025-06-18T18:11:19.149Z"

}

]

}

Consejos

- Las consultas GraphQL tienen que coincidir con sus índices GSI (no son más que consultas SQL++ bajo el capó).
- Puede utilizar índices de cubiertas y otros índices SQL++ para mejorar el rendimiento.

OData

Microsoft.AspNetCore.OData expone tus datos de EF Core como puntos finales OData, facilitando la conexión de herramientas como Excel, Power BI y Tableau a Couchbase.

Programa de ejemplo.cs

builder.Services.AddControllersWithViews()
  .AddOData(opt =>
  {
    var odataBuilder = new ODataConventionModelBuilder();
    odataBuilder.EntitySet<Widget>("Widgets");

    opt.AddRouteComponents("odata", odataBuilder.GetEdmModel())
      .Filter()
      .OrderBy()
      .Select()
      .Expand()
      .Count()
      .SetMaxTop(100);
  });

constructor.Servicios.AddControllersWithViews()

.AñadirDatos(op =>

{

var odataBuilder = nuevo ODataConventionModelBuilder();

odataBuilder.Conjunto de entidades<Widget>("Widgets");

op.AddRouteComponents("odata", odataBuilder.GetEdmModel())

.Filtro()

.OrderBy()

.Seleccione()

.Ampliar()

.Cuenta()

.SetMaxTop(100);

});

Controlador

[HttpGet("/odata/Widgets")]
[EnableQuery]
public IQueryable<Widget> GetOData() => _context.Widgets;

[HttpGet("/odata/Widgets")]

[EnableQuery]

público IQueryable<Widget> GetOData() => _contexto.Widgets;

Ejemplo de consultas OData

- https://localhost:7037/odata/Widgets?$filter=price gt 1&$orderby=nombre
- https://localhost:7037/odata/Widgets?$select=name,price&$top=10

Nota: Asegúrate de que tus consultas EF Core LINQ se pueden traducir a SQL++ y que cualquier campo filtrado/clasificado está indexado en Couchbase.

Conclusión

Todas estas integraciones están respaldadas por EF Core y ahora, con el soporte de Couchbase, puedes aprovecharlas al máximo en tu código. Tanto si estás creando aplicaciones web seguras, APIs GraphQL o integrándote con herramientas de BI, el combo EF Core y Couchbase lo hace posible.

¿Quiere ver más? Díganos qué integraciones le gustaría explorar a continuación.

Matthew Groves

Comparte este artículo

Platform

Self-Managed

Services

Capabilities

Why Couchbase?

Migrate to Capella

By Use Case

By Industry

By Application Need

Popular Docs

By Developer Role

Quickstart

Resource Center

About

Partnerships

Our Services

Partners: Register a Deal

Ready to register a deal with Couchbase?

Marriott

3 integraciones de EF Core que funcionan con Couchbase

Identidad ASP.NET Core

Ejemplo de configuración de EF

MVC auth ejemplo

GraphQL con chocolate caliente

Configurar

Ejemplo de uso

Consejos

OData

Programa de ejemplo.cs

Controlador

Ejemplo de consultas OData

Conclusión

Recibe actualizaciones del blog de Couchbase en tu bandeja de entrada

Autor

Publicado por Matthew Groves

Deja un comentario Cancelar respuesta

¿Listo para empezar con Couchbase Capella?

Empezar a construir

Utilizar Capella gratis

Póngase en contacto