Etiqueta: .NET 10

Si hay algo que me gusta de trabajar con .NET es que el ecosistema no se detiene. Hace unos años, cuando arranqué a usar Entity Framework, la discusión era «¿EF o Dapper?». Hoy esa discusión todavía existe, pero EF Core evolucionó tanto que la balanza se inclinó bastante. En este artículo repaso todas las novedades que llegaron desde .NET 8 hasta .NET 10, con ejemplos concretos y el contexto necesario para entender por qué cada feature importa.

Novedades en EF Core 8 (.NET 8)

La versión 8 fue la que me hizo replantear varios patrones que venía usando desde hace tiempo. Especialmente los Tipos Complejos, que resolvieron algo que siempre me molestó de las Owned Entities.

1. Tipos Complejos (Complex Types)

Cuando modelamos Value Objects en DDD, la lógica indica que un objeto como Dirección no tiene identidad propia: se define por sus atributos. Antes de EF8, si querías mapear esto usabas Owned Entities, que internamente requerían una clave primaria oculta y te generaban joins innecesarios. Con los Complex Types en EF Core 8, las propiedades del objeto se mapean directamente como columnas en la tabla del padre. Sin clave, sin tabla aparte, sin overhead.

[ComplexType]
public class Direccion
{
    public string Calle { get; set; }
    public string Ciudad { get; set; }
}

public class Cliente
{
    public int Id { get; set; }
    public string Nombre { get; set; }
    
    // Se mapeará como columnas Calle y Ciudad en la tabla Clientes
    public required Direccion DireccionResidencia { get; set; } 
}

En producción esto se traduce en columnas como DireccionResidencia_Calle y DireccionResidencia_Ciudad directamente en la tabla Clientes. Mucho más limpio y sin el overhead de las relaciones.

2. Colecciones de Tipos Primitivos

Otro punto de dolor histórico: guardar una lista de strings o enteros. La solución clásica era crear una tabla auxiliar o serializar a mano. EF Core 8 lo resuelve nativamente: en SQL Server serializa a JSON automáticamente, en PostgreSQL usa tipos de array nativos.

public class Producto
{
    public int Id { get; set; }
    public string Nombre { get; set; }
    public List<string> Etiquetas { get; set; } = new();
}

// EF Core traduce esto a funciones JSON en SQL Server
var productos = context.Productos
    .Where(p => p.Etiquetas.Contains("Urgente"))
    .ToList();

La primera vez que vi esto funcionar en un query real me sorprendió. EF genera el JSON_VALUE correspondiente en SQL Server y la consulta funciona sin traer entidades a memoria.

3. Consultas SQL Nativas para Tipos No Mapeados (SqlQuery)

Cuando necesitás ejecutar SQL crudo que retorna un escalar o un DTO que no está en tu DbContext, antes tenías que recurrir a ADO.NET o trucos con FromSqlRaw. Con SqlQuery<T> ya no.

var salarios = await context.Database
    .SqlQuery<decimal>($"SELECT AVG(Salario) AS Value FROM Empleados")
    .ToListAsync();

Lo que más me gusta es que podés componer LINQ encima de este resultado, combinando la potencia del SQL manual con las ventajas del query pipeline de EF.

Novedades en EF Core 9 (.NET 9)

Con .NET 9, el foco se desplazó hacia rendimiento extremo e inteligencia artificial. Dos temas que, honestamente, no esperaba ver tan rápido en el ORM.

4. Búsqueda Vectorial (Vector Search)

Si estás construyendo aplicaciones con IA generativa, tarde o temprano necesitás almacenar y consultar embeddings. EF Core 9 introduce soporte de primera clase para esto en SQL Server, PostgreSQL (con pgvector) y Cosmos DB. Esto es clave para patrones como RAG (Retrieval Augmented Generation).

public class Documento
{
    public int Id { get; set; }
    public string Contenido { get; set; }
    public ReadOnlyMemory<float> Embedding { get; set; }
}

ReadOnlyMemory<float> vectorBusqueda = ObtenerVector("¿cómo configuro autenticación?");

var docs = await context.Documentos
    .OrderBy(d => EF.Functions.VectorDistance(d.Embedding, vectorBusqueda)) 
    .Take(5)
    .ToListAsync();

En un proyecto donde implementé un chatbot sobre documentación interna, esto redujo el tiempo de integración a la mitad. Antes había que saltar a SDKs separados; ahora EF Core maneja el acceso al store vectorial junto con el resto de la lógica de datos.

5. Optimizaciones de Rendimiento y Native AOT

EF Core 9 habilita compatibilidad con compilación Native AOT, lo que significa arranques de aplicación drásticamente más rápidos y menor consumo de memoria. En microservicios y funciones serverless esto no es un detalle: es la diferencia entre ser viable o no. El modelo compilado pre-genera el mapeo en tiempo de build, eliminando la reflexión en runtime.

6. Mejoras en Actualizaciones y Borrados Masivos

ExecuteUpdate y ExecuteDelete se introdujeron en EF7, pero en EF9 se potenciaron para soportar actualizaciones de Complex Types y traducir expresiones LINQ más avanzadas. Lo importante: siguen sin traer entidades a memoria.

await context.Productos
    .Where(p => p.Categoria == "Herramientas")
    .ExecuteUpdateAsync(s => s.SetProperty(p => p.Precio, p => p.Precio * 1.10m));

Una sola query SQL de UPDATE. Sin SaveChanges, sin tracking, sin roundtrips innecesarios.

Novedades en EF Core 10 (.NET 10)

.NET 10 se lanzó en noviembre de 2025 y la versión de EF Core que lo acompaña terminó de pulir varias aristas que la comunidad venía pidiendo. Algunas son pequeñas pero hacen una diferencia real en el día a día.

7. Operadores Explícitos LeftJoin y RightJoin

¿Cuántas veces escribiste un GroupJoin + SelectMany + DefaultIfEmpty solo para hacer un LEFT JOIN? Demasiadas. EF Core 10 lo resuelve con operadores directos.

var clientesConYsinPedidos = await context.Clientes
    .LeftJoin(
        context.Pedidos,
        c => c.Id,
        p => p.ClienteId,
        (c, p) => new { c.Nombre, PedidoId = p?.Id }
    ).ToListAsync();

Mucho más legible. La intención queda clara en el código sin tener que descifrar la cascada de lambdas.

8. Flexibilidad en ExecuteUpdateAsync (Lambdas)

Las actualizaciones masivas ahora permiten lambdas regulares en lugar de árboles de expresión estrictos. Esto permite agrupar setters en bloques más limpios, especialmente cuando actualizás múltiples propiedades a la vez.

await context.Productos.Where(p => p.Stock < 10)
    .ExecuteUpdateAsync(s => {
        s.SetProperty(p => p.RequiereReabastecimiento, true);
        s.SetProperty(p => p.FechaAviso, DateTime.UtcNow);
    });

9. Columnas JSON Avanzadas para Tipos Complejos

Combinando lo mejor de dos mundos: los Complex Types de EF8 ahora pueden mapearse directamente como documentos JSON en una sola columna, con capacidad de consulta LINQ nativa dentro de ese JSON.

modelBuilder.Entity<Usuario>()
    .ComplexProperty(u => u.Preferencias, p => p.ToJson());

// Consulta dentro del JSON sin traer todo a memoria
var usuarios = await context.Usuarios
    .Where(u => u.Preferencias.Tema == "Dark")
    .ToListAsync();

10. Filtros de Consulta Nombrados (Named Query Filters)

Los global query filters (soft delete, multitenancy) son muy útiles, pero el problema siempre fue que para ignorar uno tenías que ignorarlos todos. EF Core 10 le pone nombre a cada filtro, permitiéndote desactivar solo el que necesitás.

modelBuilder.Entity<Blog>().HasQueryFilter("FiltroBorrados", b => !b.EstaBorrado);

// Solo ignoro el filtro de borrados, el de tenant sigue activo
var blogs = await context.Blogs
    .IgnoreQueryFilter("FiltroBorrados")
    .ToListAsync();

En aplicaciones multitenant con soft delete, esto es oro puro. Ya no hay que elegir entre ver los registros borrados o perder el filtro de tenant.

11. Búsqueda Híbrida y Full-Text (Cosmos DB)

Para los que trabajan con Cosmos DB y motores de búsqueda basados en IA, EF Core 10 introduce soporte nativo para Full-Text Search y Hybrid Search. Esta última combina similitud vectorial con búsqueda de palabras clave usando Reciprocal Rank Fusion, obteniendo lo mejor de ambos enfoques en una sola query.

var resultados = await context.Documentos
    .OrderBy(x => EF.Functions.VectorDistance(x.Embedding, vectorUsuario)) 
    .ThenBy(x => EF.Functions.FullTextRank(x.Contenido, "término exacto")) 
    .Take(5)
    .ToListAsync();

Resumen: La Evolución de EF Core en Tres Versiones

Mirando el camino recorrido de .NET 8 a .NET 10, la evolución es clara:

• .NET 8: Mejoras en modelado DDD (Complex Types), soporte nativo de colecciones primitivas, SQL más flexible.
• .NET 9: Rendimiento extremo con Native AOT, primer soporte real para IA con embeddings vectoriales.
• .NET 10: Ergonomía del desarrollador: sintaxis más limpia, JSON avanzado, filtros nombrados, búsqueda híbrida.

Si tu proyecto aún corre en EF Core 6 o 7, te recomiendo migrar. No solo por las features nuevas, sino porque el rendimiento en operaciones masivas mejoró notablemente. Personalmente, lo que más uso en el día a día son los ExecuteUpdate/ExecuteDelete para evitar cargar entidades innecesariamente, y los Complex Types para modelar Value Objects sin el overhead de las Owned Entities.

¿Tenés dudas sobre alguna feature específica o querés ver un caso de uso más complejo? Dejalo en los comentarios.