Introducción
Hola,
Antes de empezar, déjame decirte que si no sabes lo que es un ORM, deberías leerte esta entrada.
Recordemos que un ORM es una librería/framework que nos permite convertir datos entre un sistema orientado a objetos y una base de datos relacional.
Si trabajas con C# y te has peleado alguna vez con SQL, probablemente ya te preguntaste si hay una forma más simple de conectar tu código con la base de datos.
Spoiler: ¡sí la hay! Y se llama Entity Framework Core.
Pues hoy he venido a hablarte de Entity Framework Core, un ORM para C#.
Vamos a verlo …
¿Qué es Entity Framework Core?
Entity Framework Core es un ORM (Object-Relational Mapper) para C# creado por Microsoft.
Básicamente, te permite trabajar con bases de datos (como SQL Server, PostgreSQL, MySQL, etc.) usando código C# en lugar de escribir SQL directamente.
¿Eso qué significa? Básicamente, que te permite trabajar con tu base de datos como si estuvieras usando objetos normales de C#.
En lugar de escribir consultas SQL por todos lados, usas clases, propiedades y métodos. Así de fácil.
¿Y lo mejor? Entity Framework Core se encarga de traducir tus objetos en tablas, columnas y registros… sin que tengas que tocar ni una línea de SQL (a menos que quieras).
Es como tener un asistente personal que se encarga del papeleo mientras tú te concentras en la lógica de tu aplicación.
¿Suena bien, no? Pues eso es solo el comienzo.
En este entrada vamos a ver qué hace a Entity Framework Core tan útil.
Pero antes deja contarte un poco de su historia …
Historia de la evolución de Entity Framework
Todo empezó en el 2007 …
LINQ to SQL
Antes de que existiera Entity Framework, Microsoft lanzó en el 2007, LINQ to SQL con .NET Framework 3.5.
Fue la primera gran apuesta de Redmond para permitir que los desarrolladores interactuaran con bases de datos usando LINQ (Language Integrated Query). ¿La idea? Escribir consultas SQL… pero desde C#. ¡Una locura para la época!
Era sencillo, rápido y muy integrado a Visual Studio. Pero tenía un problema: sólo funcionaba con SQL Server. Además, su diseño estaba limitado y no soportaba escenarios complejos.
Entonces Microsoft dijo: “vamos a hacerlo bien desde cero”.
Microsoft dejó claro desde hace años que LINQ to SQL no seguiría evolucionando. Aunque sigue funcionando, no es recomendable para nuevos proyectos. EF (y especialmente EF Core) lo superó por completo en flexibilidad, soporte y comunidad.
Entity Framework
En el 2008 llegó Entity Framework 1.0 con ADO.NET. La promesa era grande: un ORM completo que sirviera como puente entre el mundo de los objetos en C# y las tablas de una base de datos relacional.
Pero… no fue amor a primera vista.
La primera versión era muy limitada, y la comunidad no la recibió con los brazos abiertos. Muchos incluso preferían seguir usando LINQ to SQL por su simplicidad.
EF 4.x y 5.0
El 2010 Microsoft publico EF 4.0 (no hubo versión 2 ni 3 para empatar con .NET Framework) trajo varias mejoras y, lo más importante, llegó Code First en la 4.1.
Ahora sí: podías escribir tus clases y dejar que EF generara la base de datos. Adiós a diseñadores visuales, hola a la libertad del código.
EF 5.0 consolidó muchas mejoras: soporte para enums, spatial data types, y más rendimiento.
EF 6: El ORM maduro
En 2013, con EF 6, Microsoft cerró un ciclo. Fue la versión más completa y robusta del «EF clásico«.
Pero había un gran “pero”: seguía atado a .NET Framework. Y el mundo estaba cambiando: empezaban a sonar fuerte cosas como .NET Core, Linux, Docker, y EF no podía seguirles el ritmo.
Nace EF Core
Microsoft decidió que era hora de un nuevo comienzo, así que crearon Entity Framework Core, una reescritura total del ORM, pensada para ser:
- Multiplataforma
- Modular
- Ligera
- Y compatible con .NET Core y .NET 5/6/7/8…
Eso sí, EF Core 1.0 era muy básico al principio. Muchas cosas del EF clásico no estaban (ni migraciones completas, ni lazy loading, ni group joins).
Pero con cada versión, la cosa mejoró:
Las versiones de EF Core:
- EF Core 2.x: Más estabilidad, tipos complejos, mejoras en rendimiento.
- EF Core 3.x: Reescritura de LINQ, cambios en la forma de generar SQL.
- EF Core 5.0: Mejoras masivas y alineado con .NET 5.
- EF Core 6.0: Primer LTS, más performance, más features.
- EF Core 7.0 y 8.0: Integración profunda con .NET moderno, nuevas APIs, y un enfoque brutal en rendimiento.
Lo que comenzó como una batalla entre LINQ to SQL y EF terminó con un claro ganador: Entity Framework Core. Hoy es el ORM oficial y más completo de Microsoft, pensado para trabajar en cualquier plataforma, con cualquier motor, y en cualquier tipo de proyecto.
Clase
Ahora que ya sabes qué es Entity Framework Core, es momento de arremangarse y ver cómo se usa en la vida real.
Vamos a construir algo simple, paso a paso, para que veas el flujo completo.
¿Listo?
Primero, imaginemos que queremos construir una app para guardar libros. Sí, un clásico 🙂
Creamos dos clases: Autor y Libro.
// Models/Autor.cs
public class Autor
{
public int Id { get; set; }
public string Nombre { get; set; }
public List<Libro> Libros { get; set; }
}
// Models/Libro.cs
public class Libro
{
public int Id { get; set; }
public string Titulo { get; set; }
public int AutorId { get; set; }
public Autor Autor { get; set; }
}
Contexto y Mapping
Ahora vamos a crear el contexto y mapear las propiedades de nuestras clases y las columnas de la tabla.
using Microsoft.EntityFrameworkCore;
using BibliotecaApp.Models;
namespace BibliotecaApp.Data
{
public class BibliotecaContext : DbContext
{
public BibliotecaContext(DbContextOptions<BibliotecaContext> options)
: base(options) { }
public DbSet<Autor> Autores { get; set; }
public DbSet<Libro> Libros { get; set; }
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
// Tabla: Autor
modelBuilder.Entity<Autor>(entity =>
{
entity.ToTable("Autores");
entity.HasKey(a => a.Id);
entity.Property(a => a.Nombre)
.IsRequired()
.HasMaxLength(100);
});
// Tabla: Libro
modelBuilder.Entity<Libro>(entity =>
{
entity.ToTable("Libros");
entity.HasKey(l => l.Id);
entity.Property(l => l.Titulo)
.IsRequired()
.HasMaxLength(200);
entity.Property(l => l.AutorId)
.IsRequired();
entity.HasOne(l => l.Autor)
.WithMany(a => a.Libros)
.HasForeignKey(l => l.AutorId)
.OnDelete(DeleteBehavior.Cascade); // Elimina libros al eliminar autor
});
}
}
}
Entity Framework Core mapea las propiedades automáticamente siguiendo convenciones por defecto. Pero también puedes hacerlo de forma explícita como hemos visto en el ejemplo.
Por convención Entity Framework Core asume que cada clase pública se convierte en una tabla, y cada propiedad se convierte en una columna.
Configuración
Ahora vamos a configuración la conexión a la base de datos.
En este caso utilizaremos una base de datos del tipo Sqlite:
// Program.cs
using BibliotecaApp.Data;
using Microsoft.EntityFrameworkCore;
var builder = WebApplication.CreateBuilder(args);
// Configura SQLite
builder.Services.AddDbContext<BibliotecaContext>(options =>
options.UseSqlite("Data Source=biblioteca.db"));
builder.Services.AddControllers();
var app = builder.Build();
app.MapControllers();
app.Run();
Controlador
Y ya por fin utilizaremos un controlador para crear una API para mostrarte el ejemplo:
// Controllers/LibrosController.cs
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using BibliotecaApp.Data;
using BibliotecaApp.Models;
[ApiController]
[Route("api/[controller]")]
public class LibrosController : ControllerBase
{
private readonly BibliotecaContext _context;
public LibrosController(BibliotecaContext context)
{
_context = context;
}
[HttpGet]
public async Task<ActionResult<IEnumerable<Libro>>> GetLibros()
{
return await _context.Libros.Include(l => l.Autor).ToListAsync();
}
[HttpPost]
public async Task<ActionResult<Libro>> PostLibro(Libro libro)
{
_context.Libros.Add(libro);
await _context.SaveChangesAsync();
return CreatedAtAction(nameof(GetLibros), new { id = libro.Id }, libro);
}
}
Conclusiones
Y bueno, ya llegamos al final.
En resumen, Entity Framework Core es como ese colega que te ahorra un montón de trabajo pesado.
¿Te imaginas tener que escribir manualmente todas las consultas SQL, manejar conexiones y preocuparte por cómo hablar con la base de datos? Con Entity Framework Core, todo eso pasa a segundo plano.
Es flexible, potente y se adapta tanto a proyectos pequeños como a aplicaciones empresariales.
Además, al ser multiplataforma y open source, no estás atado a Windows ni a soluciones cerradas. Puedes trabajar con SQLite, SQL Server, PostgreSQL y más, sin cambiar prácticamente nada de tu código.
Si estás desarrollando con C#, usar Entity Framework Core es casi un no-brainer. Te permite enfocarte en lo que realmente importa: la lógica de tu app, no los detalles aburridos del acceso a datos.
¿Ya lo estás usando? ¿O todavía te lo estás pensando? Dale una oportunidad, ¡quizás sea justo lo que necesitabas y no lo sabías!
