Introducción

Si desarrollas con .NET, en algún momento tuviste que decidir cómo tu aplicación se comunicaría con la base de datos. ¿Escribir SQL puro? ¿Usar un micro ORM como Dapper? ¿O adoptar un ORM completo como Entity Framework Core? Esta decisión va mucho más allá del rendimiento — impacta directamente la mantenibilidad, la testabilidad y, sobre todo, el acoplamiento de tu aplicación con la base de datos.

En este artículo exploro EF Core 8+ usando exclusivamente Fluent API para el mapeo de entidades — nunca Data Annotations. Explico qué es un ORM, comparo los más conocidos del mercado, muestro por qué EF Core ofrece una ventaja táctica y estratégica frente a micro ORMs como Dapper e implemento todos los tipos de relación posibles con ejemplos completos en C# 12. Si ya trabajas con EF Core y quieres profundizar en el mapeo avanzado, o si estás evaluando qué estrategia de acceso a datos adoptar en tu proyecto, esta guía es para ti. Para entender cómo se comporta EF Core en escenarios de alta carga, consulta también Cuello de Botella en Bases de Datos: Mensajería y Paginación.

📦 Código fuente: La implementación completa de este artículo está en el repositorio blog-zocateli-sample en GitHub. Clónalo, explóralo y adáptalo a tu contexto.


Qué Es un ORM y Cuáles Son los Más Conocidos

ORM (Object-Relational Mapping) es una técnica que mapea objetos de tu lenguaje de programación a tablas de una base de datos relacional. En lugar de escribir SQL a mano, manipulas objetos y el ORM se encarga de traducir esas operaciones a comandos SQL — INSERT, UPDATE, DELETE, SELECT — de forma transparente.

El concepto surgió para resolver el llamado impedance mismatch: la diferencia fundamental entre el modelo orientado a objetos (con herencia, polimorfismo, encapsulamiento) y el modelo relacional (con tablas, columnas, claves foráneas). Un ORM tiende ese puente automáticamente.

ORMs Completos vs Micro ORMs

Los ORMs se dividen en dos categorías con filosofías muy distintas:

TipoCaracterísticasEjemplos
ORM CompletoChange tracking, migrations, LINQ, lazy loading, mapeo automático de relacionesEF Core, Hibernate, NHibernate, SQLAlchemy, Django ORM
Micro ORMMapeo simple de query → objeto, sin tracking, sin migrations, SQL manualDapper, PetaPoco, Massive

Principales ORMs del Mercado

ORMLenguaje/PlataformaObservación
Entity Framework CoreC# / .NETORM oficial de Microsoft. Open source, multiplataforma, soporte a múltiples bases de datos
HibernateJavaEl ORM más maduro del ecosistema Java. Inspiración para NHibernate
NHibernateC# / .NETPort de Hibernate a .NET. Robusto, pero con una API más verbosa que EF Core
DapperC# / .NETMicro ORM creado por Stack Overflow. Rápido, ligero, SQL puro
SQLAlchemyPythonEl ORM más popular de Python. Soporte a Core (bajo nivel) y ORM (alto nivel)
Django ORMPythonIntegrado en Django. Simplicidad y productividad
ActiveRecordRubyIntegrado en Rails. Convención sobre configuración
SequelizeNode.jsORM para Node.js con soporte a PostgreSQL, MySQL, SQLite
PrismaNode.js / TypeScriptORM moderno con schema declarativo y type safety
TypeORMTypeScriptSoporte a decorators y Active Record/Data Mapper
GORMGoEl ORM más popular del ecosistema Go

💡 Consejo: EF Core es el ORM más utilizado del ecosistema .NET y Microsoft lo mantiene activamente. En el Stack Overflow Developer Survey aparece de forma constante entre los ORMs más populares a nivel global.


EF Core vs Mini ORMs: Más Allá del Rendimiento

Cuando se compara EF Core con Dapper, la conversación casi siempre gira en torno al rendimiento: “Dapper es más rápido”. Y es verdad — Dapper tiene menos overhead porque es esencialmente un wrapper fino sobre ADO.NET. Pero centrarse solo en microsegundos por query es perder de vista lo que realmente importa en un proyecto de software corporativo.

Lo Que EF Core Ofrece y Dapper No

FuncionalidadEF CoreDapper
Change TrackingAutomático — detecta qué cambió y genera UPDATE solo de las columnas modificadasManual — escribes el UPDATE completo
MigrationsVersionado del schema de la base de datos integradoInexistente — gestionas el DDL a mano
LINQConsultas tipadas verificadas en compilaciónSQL como string — errores solo en runtime
Relaciones.Include() / .ThenInclude() — joins automáticosEscribes el JOIN y lo mapeas manualmente
Proyecciones.Select(x => new { ... }) — genera SQL optimizadoEscribes la proyección en el SQL
TransaccionesSaveChanges() es transaccional por defectoGestionas IDbTransaction manualmente
InterceptorsHooks transversales (auditoría, soft delete, multi-tenancy)Inexistente
Abstracción de la base de datosCambio de provider sin alterar el código de la aplicaciónReescribes TODA query SQL

Desacoplamiento Total: Ventaja Táctica y Estratégica

Este es el punto más subestimado y más importante. Con EF Core, tu aplicación no conoce SQL. Conoce LINQ y entidades. El provider de EF Core traduce LINQ al SQL específico de la base de datos. Esto significa que:

Escenario táctico (corto plazo): Tu empresa usa SQL Server en producción. El costo de licencias creció. La dirección decide migrar a PostgreSQL. Con EF Core, cambias el provider (UseSqlServer → UseNpgsql), ajustas las migrations y listo. Con Dapper, reescribes cientos o miles de queries SQL que usan sintaxis específica de SQL Server (TOP, NOLOCK, CROSS APPLY, etc.).

Escenario estratégico (largo plazo): La empresa va a expandirse a multi-cloud. Algunos clientes exigen Oracle, otros PostgreSQL. Con EF Core, el mismo código de la aplicación funciona en ambos — basta configurar el provider por tenant. Con Dapper, mantienes dos bases de código SQL o usas un subconjunto limitado de SQL ANSI que ninguna base de datos implementa por completo.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
// La misma aplicación ejecutándose en bases de datos distintas — cero cambios en el código de negocio
// Basta cambiar el provider en Startup/Program.cs

// SQL Server
services.AddDbContext<AppDbContext>(options =>
    options.UseSqlServer(connectionString));

// PostgreSQL
services.AddDbContext<AppDbContext>(options =>
    options.UseNpgsql(connectionString));

// Oracle
services.AddDbContext<AppDbContext>(options =>
    options.UseOracle(connectionString));

// SQLite (para pruebas)
services.AddDbContext<AppDbContext>(options =>
    options.UseSqlite("Data Source=:memory:"));

ℹ️ Información: El desacoplamiento de la base de datos no es un lujo técnico — es una decisión de negocio. Las empresas que acoplan su aplicación al SQL de la base de datos quedan rehenes de licencias, vendor lock-in y costos de migración. Con EF Core, cambiar de base de datos es una decisión de configuración, no de reescritura. Para ver cómo funciona EF Core con distintas bases de datos en la práctica, consulta Paginación en APIs REST con C# y EF Core: Guía Práctica.

Diagrama de abstracción de EF Core mostrando la aplicación C# con LINQ conectándose a PostgreSQL, SQL Server, Oracle y SQLite sin cambios de código


Por Qué Fluent API y Nunca Data Annotations

EF Core ofrece dos formas de configurar el mapeo entre entidades y tablas: Data Annotations (atributos que decoran las clases) y Fluent API (configuración en clases separadas). Este artículo usa exclusivamente Fluent API, y este es el motivo:

Data Annotations — El Problema

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
// ❌ NO HAGAS ESTO — las Data Annotations contaminan el dominio
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

[Table("produtos")]
public class Produto
{
    [Key]
    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
    public int Id { get; set; }

    [Required]
    [MaxLength(200)]
    [Column("nome_produto")]
    public string Nome { get; set; } = string.Empty;

    [Column(TypeName = "decimal(18,2)")]
    public decimal Preco { get; set; }
}

El problema es claro: tu entidad de dominio está contaminada con detalles de infraestructura. La clase Produto ahora depende de System.ComponentModel.DataAnnotations y System.ComponentModel.DataAnnotations.Schema — namespaces que son responsabilidad de la capa de datos, no del dominio. Esto viola el principio de Separación de Responsabilidades (SoC) y hace imposible tener un proyecto Domain verdaderamente independiente.

Fluent API — La Solución

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
// ✅ Entidad de dominio limpia — sin ninguna referencia a EF Core
namespace MeuEcommerce.Domain.Entities;

public class Produto
{
    public int Id { get; private set; }
    public string Nome { get; private set; } = string.Empty;
    public decimal Preco { get; private set; }
    public bool Ativo { get; private set; } = true;
    public DateTime CriadoEm { get; private set; }

    public int CategoriaId { get; private set; }
    public Categoria Categoria { get; private set; } = null!;
    public ProdutoDetalhe? Detalhe { get; private set; }
    public ICollection<Tag> Tags { get; private set; } = [];
}

La configuración queda en una clase separada, en el proyecto de infraestructura:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// Infra.Data/Configurations/ProdutoConfiguration.cs
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Builders;
using MeuEcommerce.Domain.Entities;

namespace MeuEcommerce.Infra.Data.Configurations;

public class ProdutoConfiguration : IEntityTypeConfiguration<Produto>
{
    public void Configure(EntityTypeBuilder<Produto> builder)
    {
        builder.ToTable("produtos");

        builder.HasKey(p => p.Id);

        builder.Property(p => p.Nome)
            .HasMaxLength(200)
            .IsRequired();

        builder.Property(p => p.Preco)
            .HasColumnType("decimal(18,2)");

        builder.Property(p => p.Ativo)
            .HasDefaultValue(true);

        builder.Property(p => p.CriadoEm)
            .HasDefaultValueSql("NOW()");

        builder.HasIndex(p => p.Nome);
    }
}

⚠️ Atención: Las Data Annotations tienen limitaciones técnicas reales: no soportan la configuración de índices compuestos, filtros globales, conversores de valor, shadow properties, owned types y varios otros recursos avanzados. Fluent API es la única forma de acceder al 100% de las funcionalidades de EF Core.

Ventajas de la Fluent API

  1. Dominio limpio — las entidades son POCOs puros sin dependencia de EF Core
  2. Separación de responsabilidades — el mapeo queda en el proyecto de infra, no en el dominio
  3. Poder total — acceso a todas las funcionalidades de EF Core
  4. Organización — una clase IEntityTypeConfiguration<T> por entidad
  5. Testabilidad — las entidades pueden instanciarse sin mock de EF Core
  6. Principio abierto/cerrado — agregar configuración no altera la entidad

Configurando el DbContext

El DbContext es el punto central de EF Core. Representa la sesión con la base de datos y coordina el Change Tracking, las queries y el SaveChanges. Con Fluent API, el DbContext aplica automáticamente todas las configuraciones vía ApplyConfigurationsFromAssembly:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
using Microsoft.EntityFrameworkCore;
using MeuEcommerce.Domain.Entities;

namespace MeuEcommerce.Infra.Data;

public class AppDbContext(DbContextOptions<AppDbContext> options)
    : DbContext(options)
{
    public DbSet<Produto> Produtos => Set<Produto>();
    public DbSet<Categoria> Categorias => Set<Categoria>();
    public DbSet<Tag> Tags => Set<Tag>();
    public DbSet<ProdutoDetalhe> ProdutoDetalhes => Set<ProdutoDetalhe>();
    public DbSet<Comentario> Comentarios => Set<Comentario>();
    public DbSet<Pagamento> Pagamentos => Set<Pagamento>();

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // Aplica TODAS las IEntityTypeConfiguration<T> del assembly automáticamente
        // No hace falta registrarlas una por una — agrega nuevas clases y se
        // detectan automáticamente vía reflection
        modelBuilder.ApplyConfigurationsFromAssembly(
            typeof(AppDbContext).Assembly);
    }
}

💡 Consejo: Usa el primary constructor de C# 12 (public class AppDbContext(DbContextOptions<AppDbContext> options)) para simplificar el constructor. Y prefiere DbSet<T> Produtos => Set<T>(); en lugar de DbSet<T> Produtos { get; set; } — es más limpio y seguro.


Todos los Tipos de Relación con Fluent API

Uso un dominio de e-commerce para demostrar todos los tipos de relación. Primero, las entidades del dominio (proyecto Domain — sin referencia a EF Core):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
namespace MeuEcommerce.Domain.Entities;

public class Categoria
{
    public int Id { get; private set; }
    public string Nome { get; private set; } = string.Empty;
    public string? Descricao { get; private set; }
    public bool Ativa { get; private set; } = true;
    public DateTime CriadoEm { get; private set; }
    public ICollection<Produto> Produtos { get; private set; } = [];
}

public class Tag
{
    public int Id { get; private set; }
    public string Nome { get; private set; } = string.Empty;
    public ICollection<Produto> Produtos { get; private set; } = [];
}

public class ProdutoDetalhe
{
    public int Id { get; private set; }
    public string DescricaoCompleta { get; private set; } = string.Empty;
    public string? Especificacoes { get; private set; }
    public double PesoKg { get; private set; }
    public int ProdutoId { get; private set; }
    public Produto Produto { get; private set; } = null!;
}

public class Comentario
{
    public int Id { get; private set; }
    public string Texto { get; private set; } = string.Empty;
    public DateTime CriadoEm { get; private set; }
    public int ProdutoId { get; private set; }
    public Produto Produto { get; private set; } = null!;

    // Autorreferencia (respuesta a otro comentario)
    public int? ComentarioPaiId { get; private set; }
    public Comentario? ComentarioPai { get; private set; }
    public ICollection<Comentario> Respostas { get; private set; } = [];
}

Relación Uno a Muchos (1:N)

La relación más común. Una Categoria tiene muchos Produtos:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class CategoriaConfiguration : IEntityTypeConfiguration<Categoria>
{
    public void Configure(EntityTypeBuilder<Categoria> builder)
    {
        builder.ToTable("categorias");
        builder.HasKey(c => c.Id);

        builder.Property(c => c.Nome)
            .HasMaxLength(100)
            .IsRequired();

        builder.Property(c => c.Descricao)
            .HasMaxLength(500);

        builder.Property(c => c.Ativa)
            .HasDefaultValue(true);

        builder.Property(c => c.CriadoEm)
            .HasDefaultValueSql("NOW()");

        builder.HasIndex(c => c.Nome)
            .IsUnique();

        // 1:N — Una Categoria tiene muchos Produtos
        builder.HasMany(c => c.Produtos)
            .WithOne(p => p.Categoria)
            .HasForeignKey(p => p.CategoriaId)
            .OnDelete(DeleteBehavior.Restrict); // Impide eliminar una categoría con productos
    }
}

Relación Uno a Uno (1:1)

Un Produto tiene un ProdutoDetalhe (y viceversa):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class ProdutoDetalheConfiguration : IEntityTypeConfiguration<ProdutoDetalhe>
{
    public void Configure(EntityTypeBuilder<ProdutoDetalhe> builder)
    {
        builder.ToTable("produto_detalhes");
        builder.HasKey(d => d.Id);

        builder.Property(d => d.DescricaoCompleta)
            .HasMaxLength(4000)
            .IsRequired();

        builder.Property(d => d.Especificacoes)
            .HasColumnType("text");

        builder.Property(d => d.PesoKg)
            .HasColumnType("double precision");

        // 1:1 — Un ProdutoDetalhe pertenece exactamente a un Produto
        builder.HasOne(d => d.Produto)
            .WithOne(p => p.Detalhe)
            .HasForeignKey<ProdutoDetalhe>(d => d.ProdutoId)
            .OnDelete(DeleteBehavior.Cascade);

        builder.HasIndex(d => d.ProdutoId)
            .IsUnique(); // Garantiza que cada producto tenga como máximo 1 detalle
    }
}

Relación Muchos a Muchos (N:N)

Un Produto puede tener varias Tags, y una Tag puede estar en varios Produtos. Desde EF Core 5, el N:N funciona sin una tabla intermedia explícita. En EF Core 8+, puedes configurarlo vía Fluent API para tener control total:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
public class ProdutoConfiguration : IEntityTypeConfiguration<Produto>
{
    public void Configure(EntityTypeBuilder<Produto> builder)
    {
        builder.ToTable("produtos");
        builder.HasKey(p => p.Id);

        builder.Property(p => p.Nome)
            .HasMaxLength(200)
            .IsRequired();

        builder.Property(p => p.Sku)
            .HasMaxLength(50)
            .IsRequired();

        builder.Property(p => p.Preco)
            .HasColumnType("decimal(18,2)");

        builder.Property(p => p.Ativo)
            .HasDefaultValue(true);

        builder.Property(p => p.CriadoEm)
            .HasDefaultValueSql("NOW()");

        builder.HasIndex(p => p.Sku)
            .IsUnique();

        // N:N — Produto ↔ Tag (tabla intermedia configurada por EF Core)
        builder.HasMany(p => p.Tags)
            .WithMany(t => t.Produtos)
            .UsingEntity<Dictionary<string, object>>(
                "produto_tags", // Nombre de la tabla intermedia
                right => right.HasOne<Tag>()
                    .WithMany()
                    .HasForeignKey("TagId")
                    .OnDelete(DeleteBehavior.Cascade),
                left => left.HasOne<Produto>()
                    .WithMany()
                    .HasForeignKey("ProdutoId")
                    .OnDelete(DeleteBehavior.Cascade),
                join =>
                {
                    join.HasKey("ProdutoId", "TagId");
                    join.ToTable("produto_tags");
                });
    }
}

💡 Consejo: Si necesitas propiedades adicionales en la tabla intermedia (como DataAssociacao), crea una entidad explícita en lugar de usar Dictionary<string, object>. EF Core 8+ lo soporta de forma nativa con UsingEntity<ProdutoTag>().

Autorreferencia

Un Comentario puede ser respuesta a otro Comentario — es una relación 1:N consigo mismo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public class ComentarioConfiguration : IEntityTypeConfiguration<Comentario>
{
    public void Configure(EntityTypeBuilder<Comentario> builder)
    {
        builder.ToTable("comentarios");
        builder.HasKey(c => c.Id);

        builder.Property(c => c.Texto)
            .HasMaxLength(2000)
            .IsRequired();

        builder.Property(c => c.CriadoEm)
            .HasDefaultValueSql("NOW()");

        // 1:N con Produto
        builder.HasOne(c => c.Produto)
            .WithMany()
            .HasForeignKey(c => c.ProdutoId)
            .OnDelete(DeleteBehavior.Cascade);

        // Autorreferencia — un Comentario puede tener respuestas
        builder.HasOne(c => c.ComentarioPai)
            .WithMany(c => c.Respostas)
            .HasForeignKey(c => c.ComentarioPaiId)
            .OnDelete(DeleteBehavior.Restrict) // No elimina en cascada (mantiene las respuestas)
            .IsRequired(false); // FK nullable — los comentarios raíz no tienen padre

        builder.HasIndex(c => c.ProdutoId);
        builder.HasIndex(c => c.ComentarioPaiId);
    }
}

Herencia en EF Core 8+: TPH, TPT y TPC

EF Core soporta tres estrategias para mapear jerarquías de herencia a tablas:

Entidades de Dominio (Herencia)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
namespace MeuEcommerce.Domain.Entities;

public abstract class Pagamento
{
    public int Id { get; private set; }
    public decimal Valor { get; private set; }
    public DateTime PagoEm { get; private set; }
    public int PedidoId { get; private set; }
}

public class PagamentoCartao : Pagamento
{
    public string UltimosDigitos { get; private set; } = string.Empty;
    public string Bandeira { get; private set; } = string.Empty;
    public int Parcelas { get; private set; }
}

public class PagamentoPix : Pagamento
{
    public string ChavePix { get; private set; } = string.Empty;
    public string TransacaoId { get; private set; } = string.Empty;
}

public class PagamentoBoleto : Pagamento
{
    public string CodigoBarras { get; private set; } = string.Empty;
    public DateTime Vencimento { get; private set; }
}

Table Per Hierarchy (TPH) — Una Tabla para Toda la Jerarquía

Todas las clases en la misma tabla. EF Core usa una columna discriminator para saber de qué tipo es cada fila:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
public class PagamentoTphConfiguration : IEntityTypeConfiguration<Pagamento>
{
    public void Configure(EntityTypeBuilder<Pagamento> builder)
    {
        builder.ToTable("pagamentos");
        builder.HasKey(p => p.Id);

        // TPH — el Discriminator define el tipo concreto
        builder.HasDiscriminator<string>("tipo_pagamento")
            .HasValue<PagamentoCartao>("cartao")
            .HasValue<PagamentoPix>("pix")
            .HasValue<PagamentoBoleto>("boleto");

        builder.Property(p => p.Valor)
            .HasColumnType("decimal(18,2)");

        builder.Property(p => p.PagoEm)
            .HasDefaultValueSql("NOW()");
    }
}

Table Per Type (TPT) — Una Tabla por Clase

Cada clase tiene su propia tabla. La tabla base contiene las propiedades comunes, y cada tabla derivada contiene solo las propiedades específicas + una FK a la tabla base:

1
2
3
4
5
6
// TPT — Cada tipo tiene su propia tabla con FK a pagamentos
builder.ToTable("pagamentos"); // Tabla base

builder.Entity<PagamentoCartao>().ToTable("pagamentos_cartao");
builder.Entity<PagamentoPix>().ToTable("pagamentos_pix");
builder.Entity<PagamentoBoleto>().ToTable("pagamentos_boleto");

Table Per Concrete Type (TPC) — EF Core 7+

Cada clase concreta tiene su propia tabla completa (sin tabla base). Cada tabla contiene todas las columnas — tanto de la base como de la derivada:

1
2
3
4
5
6
// TPC — Cada clase concreta es una tabla independiente (EF Core 7+)
builder.UseTpcMappingStrategy();

builder.Entity<PagamentoCartao>().ToTable("pagamentos_cartao");
builder.Entity<PagamentoPix>().ToTable("pagamentos_pix");
builder.Entity<PagamentoBoleto>().ToTable("pagamentos_boleto");
EstrategiaProsContrasCuándo usar
TPHRendimiento (1 tabla, sin JOINs)Columnas nullable para tipos derivadosPocos tipos, acceso frecuente
TPTSchema normalizadoJOIN en cada query + peor rendimientoUn schema limpio importa más que el rendimiento
TPCSin JOINs, sin columnas nullableColumnas duplicadas entre tablas, UNION para queries polimórficasTipos que rara vez se consultan juntos

⚠️ Atención: Para la mayoría de los escenarios, TPH es la opción recomendada por Microsoft y por la comunidad. TPT tiene problemas de rendimiento conocidos por exigir JOINs en cada query. TPC (EF Core 7+) es útil cuando cada tipo concreto se consulta de forma independiente.


Funcionalidades Avanzadas de EF Core 8+

Value Converters

Permiten transformar valores entre C# y la base de datos. Útiles para persistir enums como string, cifrar campos o convertir tipos complejos:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
// Convertir enum a string en la base de datos
public enum StatusPedido
{
    Pendente,
    Aprovado,
    Enviado,
    Entregue,
    Cancelado
}

// En la configuración Fluent API:
builder.Property(p => p.Status)
    .HasConversion<string>() // Persiste el enum como string ("Pendente", "Aprovado", etc.)
    .HasMaxLength(20);

// O con un converter personalizado:
builder.Property(p => p.Status)
    .HasConversion(
        v => v.ToString().ToLowerInvariant(),
        v => Enum.Parse<StatusPedido>(v, ignoreCase: true));

Global Query Filters

Aplican filtros automáticamente en todas las queries de una entidad. Ideales para soft delete y multi-tenancy:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
public class ProdutoConfiguration : IEntityTypeConfiguration<Produto>
{
    public void Configure(EntityTypeBuilder<Produto> builder)
    {
        // Filtro global — las queries NUNCA devuelven productos inactivos
        // SELECT * FROM produtos WHERE ativo = true (automático en toda query)
        builder.HasQueryFilter(p => p.Ativo);
    }
}

// Para ignorar el filtro cuando sea necesario (ej.: panel de administración):
var todosProdutos = await context.Produtos
    .IgnoreQueryFilters()
    .ToListAsync();

Columnas JSON (EF Core 7+)

EF Core 7+ permite mapear objetos complejos como columnas JSON en la base de datos. Ideal para datos semiestructurados:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
// Entidad con una propiedad compleja
public class Produto
{
    public int Id { get; private set; }
    public string Nome { get; private set; } = string.Empty;
    public Dimensoes Dimensoes { get; private set; } = new();
}

public class Dimensoes
{
    public double Largura { get; set; }
    public double Altura { get; set; }
    public double Profundidade { get; set; }
    public string Unidade { get; set; } = "cm";
}

// Mapeo Fluent API — Dimensoes como columna JSON
builder.OwnsOne(p => p.Dimensoes, dim =>
{
    dim.ToJson(); // Almacena como JSON en la base de datos
});

Colecciones de Tipos Primitivos (EF Core 8+)

EF Core 8 introdujo soporte nativo a colecciones de tipos primitivos — sin necesidad de una tabla separada ni de un Value Converter:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
public class Produto
{
    public int Id { get; private set; }
    public string Nome { get; private set; } = string.Empty;
    public List<string> ImagensUrls { get; private set; } = [];
    public List<string> PalavrasChave { get; private set; } = [];
}

// Mapeo — almacenado como JSON array en la base de datos
builder.Property(p => p.ImagensUrls)
    .HasColumnType("jsonb"); // PostgreSQL — o 'nvarchar(max)' para SQL Server

builder.Property(p => p.PalavrasChave)
    .HasColumnType("jsonb");

ℹ️ Información: Las colecciones de tipos primitivos de EF Core 8+ se almacenan como arrays JSON nativos. En PostgreSQL, usa jsonb para una indexación eficiente. En SQL Server, EF Core serializa automáticamente a nvarchar(max).


Consejos y Buenas Prácticas

  1. Una IEntityTypeConfiguration<T> por entidad — nunca configures múltiples entidades en OnModelCreating. Usa ApplyConfigurationsFromAssembly() para la detección automática.

  2. Configura siempre OnDelete explícitamente — el comportamiento por defecto varía entre providers. Sé explícito con DeleteBehavior.Restrict, .Cascade o .SetNull para evitar sorpresas.

  3. Usa private set; en las entidades — protege el estado interno. Las entidades de dominio deben modificarse solo mediante métodos de negocio, no con setters públicos.

  4. Configura índices para FKs y columnas de búsqueda — EF Core NO crea índices automáticamente para foreign keys en todos los providers. Usa builder.HasIndex(p => p.CategoriaId).

  5. Prefiere AsNoTracking() para queries de lectura — si no vas a modificar los datos, desactiva el Change Tracking para ganar un rendimiento significativo.

  6. Nunca expongas el DbContext directamente en la API — usa el patrón Repository o servicios intermedios. El DbContext es infraestructura.

  7. Define siempre HasMaxLength() — sin HasMaxLength, EF Core crea columnas nvarchar(max) / text, que perjudican el rendimiento e impiden la indexación.

  8. Configura HasDefaultValueSql() para columnas de fecha — usa expresiones de la base de datos (NOW(), GETUTCDATE()) para que las fechas las genere el servidor, no la aplicación.


Conclusión

Entity Framework Core 8+ con Fluent API ofrece mucho más que un simple mapeo objeto-relacional. Entrega desacoplamiento total de la base de datos — una ventaja que trasciende lo técnico e impacta directamente en el negocio. Mientras que micro ORMs como Dapper te atan al SQL específico de un vendor, EF Core permite que tu aplicación hable LINQ y deja que el provider lo traduzca al dialecto de la base de datos.

Al usar exclusivamente Fluent API con IEntityTypeConfiguration<T>, tus entidades de dominio quedan limpias, testeables y libres de cualquier dependencia de infraestructura. Las relaciones (1:1, 1:N, N:N, autorreferencia), las estrategias de herencia (TPH, TPT, TPC) y las funcionalidades avanzadas (Value Converters, Global Query Filters, columnas JSON, colecciones primitivas) convierten a EF Core en una herramienta completa para cualquier escenario de acceso a datos.

Para profundizar en la gestión de Migrations en proyectos multicapa con dotnet secrets y scaffolding de bases de datos existentes, consulta el artículo dedicado EF Core Migrations: Multiproyecto, Secrets y Scaffolding. Y si el rendimiento es tu preocupación, mira cómo se comporta EF Core en escenarios de alta carga en Cuello de Botella en Bases de Datos: Mensajería y Paginación.


Lee También


Referencias