3 EF Core Integrations That Work with Couchbase

O novo Fornecedor principal da EF abre a porta para algumas integrações poderosas do .NET: mesmo aquelas tradicionalmente vinculadas a bancos de dados relacionais. Esta postagem explica como Identidade, GraphQL e OData funcionam com o Couchbase.

Nesta postagem, vou falar sobre três integrações avançadas do EF Core que testei com sucesso com o Couchbase:

1. Identidade do ASP.NET Core
2. GraphQL (via Hot Chocolate)
3. Dados OD

Observação: Essas integrações são baseadas em testes limitados e não são oficialmente suportadas (ainda). Sua milhagem pode variar, mas, até o momento, elas são bastante promissoras.

Identidade do ASP.NET Core

Microsoft.AspNetCore.Identity.EntityFrameworkCore fornece um sistema plug-and-play de autenticação e gerenciamento de usuários para aplicativos ASP.NET.

O provedor EF Core do Couchbase funciona bem com ele. A única ressalva é que você precisará garantir que o primeiro existem coleções adequadas (como AspNetUsers, AspNetRoles, etc.).

Observação: Você deve criar as seguintes coleções com antecedência: AspNetUsers, AspNetRoles, AspNetUserRoles, AspNetUserClaims, AspNetUserLogins, AspNetUserTokens, AspNetRoleClaims.

Exemplo de configuração 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 classe AppDbContext : IdentityDbContext<Usuário do aplicativo>

{

público AppDbContext(DbContextOptions<AppDbContext> opções) : base(opções) { }

protegida anular vazio OnModelCreating(ModelBuilder construtor)

{

base.OnModelCreating(construtor);

construtor.Entidade<Usuário do aplicativo>().ToCouchbaseCollection(este, "AspNetUsers");

construtor.Entidade<IdentityRole>().ToCouchbaseCollection(este, "AspNetRoles");

construtor.Entidade<IdentityUserRole<string>>().ToCouchbaseCollection(este, "AspNetUserRoles");

construtor.Entidade<IdentityUserClaim<string>>().ToCouchbaseCollection(este, "AspNetUserClaims");

construtor.Entidade<IdentityUserLogin<string>>().ToCouchbaseCollection(este, "AspNetUserLogins");

construtor.Entidade<IdentityUserToken<string>>().ToCouchbaseCollection(este, "AspNetUserTokens");

construtor.Entidade<IdentityRoleClaim<string>>().ToCouchbaseCollection(este, "AspNetRoleClaims");

}

público classe Usuário do aplicativo : IdentityUser { }

Exemplo de autenticação MVC

Aqui está um controlador ASP.NET Core MVC com registro, login e logout, bem como uma função personalizada:

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 classe AuthController : Controlador

{

privado somente leitura Gerenciador de usuários<Usuário do aplicativo> _userManager;

privado somente leitura SignInManager<Usuário do aplicativo> _signInManager;

privado somente leitura Gerenciador de funções<IdentityRole> _roleManager;

público AuthController(Gerenciador de usuários<Usuário do aplicativo> gerenciador de usuários, SignInManager<Usuário do aplicativo> Gerenciador de login, Gerenciador de funções<IdentityRole> gerenciador de funções)

{

_userManager = gerenciador de usuários;

_signInManager = Gerenciador de login;

_roleManager = gerenciador de funções;

}

público IActionResult Registro() => Ver();

[HttpPost]

público assíncrono Tarefa<IActionResult> Registro(RegisterModel modelo)

{

se (!Estado do modelo.IsValid) retorno Ver(modelo);

var usuário = novo Usuário do aplicativo { Nome de usuário = modelo.E-mail, E-mail = modelo.E-mail };

var resultado = aguardar _userManager.CreateAsync(usuário, modelo.Senha);

se (resultado.Bem-sucedido)

{

var roleName = "CustomRole";

se (!aguardar _roleManager.RoleExistsAsync(roleName))

aguardar _roleManager.CreateAsync(novo IdentityRole(roleName));

aguardar _userManager.AddToRoleAsync(usuário, roleName);

aguardar _signInManager.SignInAsync(usuário, isPersistent: falso);

retorno RedirectToAction("Índice", "Casa");

}

antes de (var erro em resultado.Erros) Estado do modelo.AddModelError("", erro.Descrição);

retorno Ver(modelo);

}

público IActionResult Login() => Ver();

[HttpPost]

público assíncrono Tarefa<IActionResult> Login(LoginModel modelo)

{

se (!Estado do modelo.IsValid) retorno Ver(modelo);

var resultado = aguardar _signInManager.PasswordSignInAsync(modelo.E-mail, modelo.Senha, falso, falso);

se (resultado.Bem-sucedido)

retorno RedirectToAction("Índice", "Casa");

Estado do modelo.AddModelError("", "Tentativa de login inválida".);

retorno Ver(modelo);

}

público assíncrono Tarefa<IActionResult> Sair()

{

aguardar _signInManager.SignOutAsync();

retorno RedirectToAction("Índice", "Casa");

}

Os dados seguem a estrutura padrão do Identity, armazenados em um documento do Couchbase. Por exemplo, um documento em Usuário AspNet coleção:

GraphQL com chocolate quente

Chocolate quente é um servidor GraphQL popular para .NET. Ele pode se integrar ao EF Core, apoiando-se nos recursos LINQ do provedor (que o Couchbase tem). Isso significa que as consultas GraphQL são traduzidas para LINQ, que, por sua vez, é traduzido para o Couchbase SQL++.

Configuração

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 classe WidgetQuery

{

[UseFiltering]

[UseSorting]

público IQueryable<Widget> GetWidgets([Serviço] WidgetDbContext dbContext)

=> dbContext.Widgets;

}

// Program.cs:

construtor.Serviços

.AdicionarGraphQLServer()

.AddQueryType<WidgetQuery>()

.AddFiltering()

.AddSorting()

.AddProjections();

aplicativo.MapGraphQL();

Exemplo de uso

Ir para /graphql no navegador (isso abre uma interface da Web)

Tente uma consulta como esta:

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

consulta {

widgets(onde: { nome: { contém: "foo" } }, ordem: { createdDt: DESC }) {

nome

preço

numInStock

createdDt

}

Isso retornará resultados como:

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

{

"dados": {

"widgets": [

{

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

"name" (nome): "foobar",

"price" (preço): 1.99,

"numInStock": 50,

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

}

]

}

Dicas

- As consultas GraphQL precisam corresponder aos seus índices GSI (são apenas consultas SQL++ por baixo do pano).
- Você pode usar índices de capa e outros índices do SQL++ para melhorar o desempenho.

Dados OD

Microsoft.AspNetCore.OData expõe seus dados do EF Core como pontos de extremidade OData, facilitando a conexão de ferramentas como Excel, Power BI e Tableau ao Couchbase.

Programa de amostra.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);
  });

construtor.Serviços.AddControllersWithViews()

.AddOData(optar =>

{

var construtor de dados = novo ODataConventionModelBuilder();

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

optar.AddRouteComponents("odata", construtor de dados.GetEdmModel())

.Filtro()

.Ordem()

.Selecione()

.Expandir()

.Contagem()

.SetMaxTop(100);

});

Controlador

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

[HttpGet("/odata/Widgets")]

[Ativar consulta]

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

Exemplo de consultas OData

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

Observação: Certifique-se de que suas consultas LINQ do EF Core possam ser traduzidas para SQL++ e que todos os campos filtrados/classificados sejam indexados no Couchbase.

Concluindo

Todas essas integrações são respaldadas pelo EF Core - e agora, com o suporte do Couchbase, você pode tirar o máximo proveito delas em seu código. Se estiver criando aplicativos da Web seguros, APIs GraphQL ou integrando-se a ferramentas de BI, a combinação EF Core e Couchbase torna isso possível.

Curioso para ver mais? Diga-nos quais integrações você gostaria de explorar a seguir!

Matthew Groves

Compartilhe este artigo

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 integrações do EF Core que funcionam com o Couchbase

Identidade do ASP.NET Core

Exemplo de configuração de EF

Exemplo de autenticação MVC

GraphQL com chocolate quente

Configuração

Exemplo de uso

Dicas

Dados OD

Programa de amostra.cs

Controlador

Exemplo de consultas OData

Concluindo

Receba atualizações do blog do Couchbase em sua caixa de entrada

Autor

Postado por Matthew Groves

Deixe um comentário Cancelar resposta

Pronto para começar a usar o Couchbase Capella?

Iniciar a construção

Use o Capella gratuitamente

Entre em contato