3 EF Core Integrations That Work with Couchbase

Couchbase’s new EF Core provider opens the door to some powerful .NET integrations: even ones traditionally tied to relational databases. This post walks through how Identity, GraphQL, and OData all work with Couchbase.

In this post, I’ll walk through three advanced EF Core integrations that I have successfully tested with Couchbase:

ASP.NET Core Identity
GraphQL (via Hot Chocolate)
OData

Nota: These integrations are based on limited testing and are not officially supported (yet). Your mileage may vary, but so far, they show a lot of promise.

ASP.NET Core Identity

Microsoft.AspNetCore.Identity.EntityFrameworkCore provides a plug-and-play authentication and user management system for ASP.NET apps.

Couchbase’s EF Core provider works well with it. The only caveat is that you’ll need to make sure the proper collections exist first (like AspNetUsers, AspNetRoles, etc).

Nota: You must create the following collections in advance: AspNetUsers, AspNetRoles, AspNetUserRoles, AspNetUserClaims, AspNetUserLogins, AspNetUserTokens, AspNetRoleClaims.

Example EF setup

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<ApplicationUserEl resultado de tu pregunta se muestra a continuación:

{

público AppDbContext(DbContextOptions<AppDbContextEl resultado de tu pregunta se muestra a continuación: Opciones) : base(Opciones) { }

protegido anular vacío OnModelCreating(ModelBuilder constructor)

{

base.OnModelCreating(constructor);

constructor.Entidad<ApplicationUserEl resultado de tu pregunta se muestra a continuación:().ToCouchbaseCollection(este, “AspNetUsers”);

constructor.Entidad<IdentityRoleEl resultado de tu pregunta se muestra a continuación:().ToCouchbaseCollection(este, “AspNetRoles”);

constructor.Entidad<IdentityUserRole<cadena>>().ToCouchbaseCollection(este, “AspNetUserRoles”);

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

constructor.Entidad<IdentityUserLogin<cadena>>().ToCouchbaseCollection(este, “AspNetUserLogins”);

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

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

}

público clase ApplicationUser : IdentityUser { }

MVC auth example

Here’s an ASP.NET Core MVC controller with registration, login, and logout, as well as a custom role:

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 : Controller

{

privado de solo lectura UserManager<ApplicationUserEl resultado de tu pregunta se muestra a continuación: _userManager;

privado de solo lectura SignInManager<ApplicationUserEl resultado de tu pregunta se muestra a continuación: _signInManager;

privado de solo lectura RoleManager<IdentityRoleEl resultado de tu pregunta se muestra a continuación: _roleManager;

público AuthController(UserManager<ApplicationUserEl resultado de tu pregunta se muestra a continuación: userManager, SignInManager<ApplicationUserEl resultado de tu pregunta se muestra a continuación: signInManager, RoleManager<IdentityRoleEl resultado de tu pregunta se muestra a continuación: roleManager)

{

_userManager = userManager;

_signInManager = signInManager;

_roleManager = roleManager;

}

público IActionResult Register() =El resultado de tu pregunta se muestra a continuación: Ver();

[HttpPost]

público asíncrono Task<IActionResultEl resultado de tu pregunta se muestra a continuación: Register(RegisterModel modelo)

{

si (!ModelState.IsValid) regresar Ver(modelo);

var usuario = nuevo ApplicationUser { UserName = modelo.Email, Email = modelo.Email };

var resultado = esperar _userManager.CreateAsync(usuario, modelo.Password);

si (resultado.Succeeded)

{

var roleName = “CustomRole”;

si (!esperar _roleManager.RoleExistsAsync(roleName))

esperar _roleManager.CreateAsync(nuevo IdentityRole(roleName));

esperar _userManager.AddToRoleAsync(usuario, roleName);

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

regresar RedirectToAction(“Index”, “Home”);

}

para cada (var error en resultado.Errores) ModelState.AddModelError(“”, error.Description);

regresar Ver(modelo);

}

público IActionResult Login() =El resultado de tu pregunta se muestra a continuación: Ver();

[HttpPost]

público asíncrono Task<IActionResultEl resultado de tu pregunta se muestra a continuación: Login(LoginModel modelo)

{

si (!ModelState.IsValid) regresar Ver(modelo);

var resultado = esperar _signInManager.PasswordSignInAsync(modelo.Email, modelo.Password, falso, falso);

si (resultado.Succeeded)

regresar RedirectToAction(“Index”, “Home”);

ModelState.AddModelError(“”, “Invalid login attempt.”);

regresar Ver(modelo);

}

público asíncrono Task<IActionResultEl resultado de tu pregunta se muestra a continuación: Logout()

{

esperar _signInManager.SignOutAsync();

regresar RedirectToAction(“Index”, “Home”);

}

The data follows the standard Identity structure, stored in a Couchbase document. For example, a document in AspNetUser collection:

A document in AspNetUser collection

GraphQL with Hot Chocolate

Hot Chocolate is a popular GraphQL server for .NET. It can integrate with EF Core, leaning on the LINQ capabilities of the provider (which Couchbase has). This means that GraphQL queries are translated to LINQ, which is then translated to Couchbase SQL++.

Setup

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

{

[UseFiltering]

[UseSorting]

público IQueryable<WidgetEl resultado de tu pregunta se muestra a continuación: GetWidgets([Service] WidgetDbContext dbContext)

=El resultado de tu pregunta se muestra a continuación: dbContext.Widgets;

}

// Program.cs:

constructor.Servicios

.AddGraphQLServer()

.AddQueryType<WidgetQueryEl resultado de tu pregunta se muestra a continuación:()

.AddFiltering()

.AddSorting()

.AddProjections();

app.MapGraphQL();

Example usage

Go to /graphql in browser (this brings up a web interface)

Try a query like this:

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

consulta {

widgets(where: { nombre: { contains: “foo” } }, order: { createdDt: DESC }) {

identificación

nombre

price

numInStock

createdDt

}

This will return results like:

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

{

“data”: {

“widgets”: [

{

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

“nombre”: “foobar”,

“price”: 1.99,

“numInStock”: 50,

“createdDt”: “2025-06-18T18:11:19.149Z”

}

]

}

Tips

GraphQL queries need to match your GSI indexes (it’s just SQL++ queries under the hood).
You can use cover indexes and other SQL++ indexes to improve performance.

OData

Microsoft.AspNetCore.OData exposes your EF Core data as OData endpoints, making it easy to connect tools like Excel, Power BI, and Tableau to Couchbase.

Sample program.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()

.AddOData(opt =El resultado de tu pregunta se muestra a continuación:

{

var odataBuilder = nuevo ODataConventionModelBuilder();

odataBuilder.EntitySet<WidgetEl resultado de tu pregunta se muestra a continuación:(“Widgets”);

opt.AddRouteComponents(“odata”, odataBuilder.GetEdmModel())

.Filter()

.OrderBy()

.Seleccionar()

.Expand()

.Count()

.SetMaxTop(100);

});

Controller

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

[HttpGet(“/odata/Widgets”)]

[EnableQuery]

público IQueryable<WidgetEl resultado de tu pregunta se muestra a continuación: GetOData() =El resultado de tu pregunta se muestra a continuación: _context.Widgets;

Example OData queries

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

Nota: Make sure your EF Core LINQ queries can be translated to SQL++ and that any filtered/sorted fields are indexed in Couchbase.

Wrapping up

All of these integrations are backed by EF Core—and now, with Couchbase support, you can take full advantage of them in your code. Whether you’re building secure web applications, GraphQL APIs or integrating with BI tools, The EF Core and Couchbase combo makes it possible.

Curious to see more? Let us know what integrations you’d like to explore next!

Plataforma

Servicios

Autogestionado

Capacidades

Por caso de uso

Por industria

Documentos populares

Inicio rápido

Centro de Recursos

Acerca de

Alianzas

3 integraciones de EF Core que funcionan con Couchbase

Evaluación de bases de datos NoSQL: Una guía práctica

Consolidación de la pila de IA con una base de datos como servicio

Arquitectura de bases de datos vectoriales: qué deben evaluar los compradores de tecnología

Modernización de NoSQL empresarial: En qué se equivoca la planificación de la migración

Inferencia vs. Entrenamiento de IA: Diferencias Clave

¿Listo para comenzar con Couchbase Capella?

Comenzar a construir

Usa Capella gratis

Ponte en contacto

Plataforma

Servicios

Autogestionado

Capacidades

Por caso de uso

Por industria

Documentos populares

Inicio rápido

Centro de Recursos

Acerca de

Alianzas

3 integraciones de EF Core que funcionan con Couchbase

ASP.NET Core Identity

Example EF setup

MVC auth example

GraphQL with Hot Chocolate

Setup

Example usage

Tips

OData

Sample program.cs

Controller

Example OData queries

Wrapping up

Recibe las actualizaciones del blog de Couchbase en tu bandeja de entrada

Autor

Postado por Matthew Groves

Deja un comentario Cancelar respuesta

¿Listo para comenzar con Couchbase Capella?

Comenzar a construir

Usa Capella gratis

Ponte en contacto