11. Entity Framework Core
El capítulo anterior mostró cómo una aplicación .NET se comunica con una base de datos a través de un conector ADO.NET: se abre una conexión, se escriben comandos SQL, se leen las filas del resultado columna por columna y se copian en objetos. Este proceso de copia —de filas a objetos y de objetos a los comandos [INSERT], [UPDATE] y [DELETE] — es repetitivo. Se puede automatizar mediante una herramienta: un ORM (Object-Relational Mapper, mapeador objeto-relacional). Este capítulo presenta Entity Framework Core (EF Core) de Microsoft.
El curso de 2008 no mencionaba los ORM: se limitaba a citar, en la conclusión de su capítulo sobre bases de datos, los “frameworks de acceso a datos de terceros” (NHibernate, iBatis) y LINQ. Entity Framework se lanzó unos meses después (en 2008, con .NET 3.5 SP1) y, en 2012, el autor le dedicó un curso titulado “Introduction to Entity Framework 5 Code First Through Examples”. Este capítulo es completamente nuevo. Se apoya en la base de datos de ejemplo de los artículos del Capítulo 10 y concluye con la versión 7 de la aplicación de cálculo de impuestos, cuya capa [dao] utiliza EF Core.
11.1. ¿Qué es un ORM?
11.1.1. Objetos y tablas
Una aplicación C# trabaja con objetos: un artículo tiene un nombre, un precio y un nivel de existencias; un pedido tiene un cliente y una lista de líneas, cada una de las cuales hace referencia a un artículo. Una base de datos relacional almacena esta misma información en tablas: una fila en la tabla [articles] por artículo, una fila en la tabla [orders] por pedido, con las relaciones entre filas expresadas mediante claves externas. Los dos mundos no coinciden del todo:
- un objeto hace referencia directamente a otros objetos ([order.Client]); una fila contiene el valor de la clave primaria de otra fila ([ClientId]);
- un objeto puede contener una colección ([order.Lines]); una tabla solo contiene valores simples; la colección se representa mediante las filas de otra tabla que apuntan al pedido;
- los tipos de C# ([string], [decimal], [DateOnly], [bool]) y los tipos de SQL ([varchar(30)], [decimal(10,2)], [date], [tinyint(1)]) no son los mismos;
- los objetos se consultan con C# (y LINQ), y las tablas se consultan con SQL.
Un ORM tiende un puente entre los dos mundos. Se define de una vez por todas la correspondencia entre clases y tablas (el modelo) y el ORM se encarga de:
- traducir las consultas LINQ escritas en C# a comandos SQL [SELECT];
- crear objetos a partir de las filas leídas (esto se denomina materialización);
- almacenar los objetos leídos y detectar cuáles han sido modificados, agregados o eliminados;
- generar los comandos [INSERT], [UPDATE] y [DELETE] que reflejan esos cambios en la base de datos;
- y, si es necesario, crear y actualizar el esquema de la base de datos (tablas, columnas, índices) a partir de las clases.
La arquitectura de una aplicación que utiliza EF Core con MySQL es la siguiente:

- [1]: la aplicación. Su capa [dao] ya no se comunica con un conector ADO.NET sino con EF Core, mediante un objeto [DbContext] y consultas LINQ;
- [2]: EF Core, independiente del SGBD: modelo, traducción de las consultas LINQ, seguimiento de cambios, migraciones;
- [3]: el proveedor de EF Core específico del SGBD (aquí Pomelo para MySQL): conoce el dialecto SQL del SGBD y sus tipos de columna;
- [4]: el conector ADO.NET del SGBD, el del Capítulo 10 (MySqlConnector): EF Core no reemplaza a ADO.NET; lo utiliza;
- [5]: el SGBD.
11.1.2. EF Core y Entity Framework 6
Existen dos productos llamados Entity Framework:
- Entity Framework 6 (EF 6), el producto original, diseñado para .NET Framework en Windows (desde la versión 6.3, también funciona en .NET Core y sus sucesores). Todavía recibe mantenimiento, pero ya no está en desarrollo activo;
- Entity Framework Core, una reescritura completa lanzada en 2016 con .NET Core. Funciona en todas las plataformas .NET (Windows, Linux, macOS) y es la versión que recibe todas las novedades. Su número de versión sigue al de .NET: EF Core 8 con .NET 8, EF Core 9 con .NET 9, EF Core 10 con .NET 10.
Para una aplicación nueva, usamos EF Core. Ambos productos tienen API similares ([DbContext], [DbSet<T>], LINQ, migraciones), por lo que lo que se expone aquí sigue siendo válido en gran parte para EF 6.
11.1.3. Proveedores
EF Core accede a un SGBD a través de un proveedor, distribuido en un paquete NuGet. Microsoft ofrece los proveedores para SQL Server, SQLite y Azure Cosmos DB; los demás los escriben los editores de los SGBD o la comunidad: [Npgsql.EntityFrameworkCore.PostgreSQL] para PostgreSQL, [Oracle.EntityFrameworkCore] para Oracle, [Pomelo.EntityFrameworkCore.MySql] y [MySql.EntityFrameworkCore] (de Oracle) para MySQL. Utilizamos Pomelo, el proveedor de MySQL más utilizado, que se basa en el conector [MySqlConnector] del Capítulo 10.
Un proveedor se compila para una versión específica de EF Core: Pomelo 9 funciona con EF Core 9, y las versiones de Pomelo suelen publicarse varios meses después de las de EF Core. El curso utiliza EF Core 9.0.0 y Pomelo 9.0.0, sobre .NET 10. Esta combinación funciona: EF Core 9 tiene como destino .NET 8 ([net8.0]), y una biblioteca compilada para .NET 8 funciona sin modificaciones en .NET 10. El paso a EF Core 10 se logrará cambiando los números de versión de los paquetes; el código de este capítulo debería funcionar entonces sin modificaciones, salvo por algunos detalles menores en el SQL generado. Sin embargo, en la sección sobre LINQ nos encontraremos con una incompatibilidad menor entre EF Core 9 y el compilador de C# 14.
Los paquetes utilizados en este capítulo son los siguientes:
Paquete | Función |
[Microsoft.EntityFrameworkCore] 9.0.0 | EF Core propiamente dicho |
[Pomelo.EntityFrameworkCore.MySql] 9.0.0 | El proveedor de MySQL; incluye [Microsoft.EntityFrameworkCore.Relational] y [MySqlConnector] |
[Microsoft.EntityFrameworkCore.Design] 9.0.0 | el código utilizado por la herramienta de línea de comandos [dotnet ef] (migraciones) |
herramienta [dotnet-ef] 9.0.0 | la herramienta de línea de comandos [dotnet ef] |
La herramienta [dotnet ef] se instala una sola vez en la máquina de desarrollo:
Las herramientas “globales” de .NET se instalan en la carpeta [.dotnet/tools] del directorio personal del usuario, que el instalador del SDK agrega a la ruta de ejecutables (en Linux, debe agregarla usted mismo: [export PATH=$PATH:$HOME/.dotnet/tools]).
11.1.4. Code First y Database First
El modelo de EF Core (la correspondencia entre clases y tablas) puede construirse de dos maneras:
- Code First: se escriben las clases C# y EF Core deriva de ellas el esquema de la base de datos, que puede crear por sí mismo y luego actualizar a medida que evoluciona la aplicación (migraciones). Este es el enfoque adoptado en este capítulo y en el curso de 2012 del autor;
- Database First: la base de datos ya existe y se generan las clases a partir de su esquema mediante el comando [dotnet ef dbcontext scaffold]. Este es el enfoque que se utiliza en las aplicaciones que deben trabajar con una base de datos existente. El código generado es similar al que escribiríamos a mano.
11.2. Un primer ejemplo
11.2.1. El proyecto
Cada ejemplo de este capítulo es un proyecto de consola: la herramienta [dotnet ef], utilizada para las migraciones, requiere un archivo de proyecto [.csproj]. Los proyectos están agrupados en la solución [11-efcore/11-efcore.slnx]. El primero, [First], se crea con los siguientes comandos:
Su archivo de proyecto es el siguiente:
- Líneas 12–13: los dos paquetes agregados por [dotnet add package].
La base de datos utilizada es la base [efarticles] del servidor MySQL local, que es el servidor de Laragon (véanse los apéndices). No es necesario que exista: EF Core la creará.
11.2.2. La entidad [Article]
Una clase cuyos objetos se almacenan en una tabla se denomina entidad. Nuestra primera entidad es un artículo de tienda, como en la tabla [articles] del curso de 2008, tratada en el Capítulo 10:
- Línea 4: una clase C# normal. No hereda de ninguna clase de EF Core y no tiene atributos; esto se conoce como un POCO (Plain Old CLR Object);
- Línea 7: la propiedad [Id] será la clave primaria de la tabla. Esto es una convención de EF Core: una propiedad llamada [Id] (o [ArticleId], el nombre de la clase seguido de [Id]) es la clave primaria. Como es de tipo entero, sus valores serán generados por el SGBD (columna [AUTO_INCREMENT] de MySQL);
- líneas 9–12: cada propiedad pública de lectura/escritura se convierte en una columna con el mismo nombre. La propiedad [Name] se inicializa con una cadena vacía para satisfacer al compilador (tipos que admiten valores nulos habilitados: una propiedad de tipo [string] no debe quedar en [null]);
- línea 15: una presentación cómoda del artículo.
11.2.3. Contexto
El acceso a la base de datos se gestiona mediante un objeto de tipo [DbContext]:
- Línea 7: la clase [DbContext] proviene de EF Core. Un objeto [ArticlesContext] representa una sesión de trabajo con la base de datos: abre la conexión cuando es necesario, almacena las entidades que ha leído y puede guardar los cambios realizados en ellas;
- Línea 10: un [DbSet<Article>] representa la tabla de artículos. Aquí se ejecutan las consultas LINQ y se agregan o eliminan artículos. La propiedad se define como un miembro con cuerpo de expresión que llama a [Set<Article>()]: cada [DbSet<T>] declarado en el contexto introduce el tipo [T] en el modelo;
- línea 13: EF Core llama al método [OnConfiguring] la primera vez que se utiliza el contexto, para configurarlo;
- línea 15: la cadena de conexión, la misma que en el Capítulo 10: servidor, puerto, base de datos, nombre de usuario y contraseña (vacía para el usuario [root] de Laragon);
- línea 18: el contexto utiliza el proveedor Pomelo. El segundo parámetro especifica la versión del servidor MySQL: el SQL generado depende de ella, ya que ciertas funcionalidades solo están disponibles en versiones recientes. Laragon proporciona MySQL 8; especificamos la versión 8.0.36. Pomelo también ofrece [ServerVersion.AutoDetect(connection)], que consulta al servidor para determinar su versión. Esto es cómodo, pero implica una conexión adicional cada vez que se configura un contexto, y el SQL generado pasa a depender del servidor encontrado. Especificar una versión de forma explícita hace que el comportamiento de la aplicación sea reproducible;
- línea 20: el método [LogTo] indica a EF Core que escriba su registro mediante el método [Console.WriteLine]. Conservamos únicamente la categoría de mensajes [DbLoggerCategory.Database.Command] —la de los comandos SQL ejecutados— en el nivel [LogLevel.Information]. Sin este filtro, el registro es muy detallado. Ver el SQL enviado al servidor es la mejor manera de comprender lo que hace EF Core: lo haremos en todos los ejemplos.
11.2.4. El programa
- línea 4: crea el contexto. Una declaración [using] (C# 8) garantiza que se liberará ([Dispose]) al final del programa, lo que cierra cualquier conexión que haya abierto;
- línea 7: [context.Database.EnsureDeleted()] elimina la base de datos si existe;
- línea 8: [context.Database.EnsureCreated()] crea la base de datos y sus tablas a partir del esquema. Estos dos métodos son cómodos para ejemplos y pruebas; una aplicación real actualiza su base de datos mediante migraciones, que veremos más adelante;
- Líneas 11–13: se agregan tres artículos al [DbSet]. Todavía no se ha enviado nada al servidor: el contexto solo recuerda que estos tres objetos deben insertarse. No asignamos ningún valor a la propiedad [Id], que generará el SGBD;
- línea 15: [SaveChanges] envía al servidor todos los comandos SQL necesarios para guardar los cambios almacenados y devuelve el número de filas afectadas;
- línea 20: una consulta LINQ sobre [DbSet]: los artículos en orden alfabético. El SGBD la ejecuta cuando el bucle [foreach] comienza a recorrerla.
Resultados:
Comentarios:
- Cada comando SQL va precedido de un encabezado de dos líneas: el tipo de evento ([CommandExecuted]), el tiempo de ejecución y los parámetros del comando;
- línea 4: [EnsureDeleted] eliminó la base de datos, que ya existía (el programa ya se había ejecutado);
- líneas 7–20: [EnsureCreated] creó la base de datos, le asignó el conjunto de caracteres [utf8mb4] (el conjunto Unicode completo de MySQL) y luego creó la tabla [Articles] a partir de la entidad [Article]: el nombre de la tabla es el de la propiedad [DbSet] del contexto, las columnas se nombran según las propiedades y la columna [Id] es la clave primaria con un valor generado ([AUTO_INCREMENT]). Todas las columnas son [NOT NULL]: los tipos [int] y [decimal] no admiten el valor [null], ni tampoco el tipo [string], ya que los tipos que admiten valores nulos están habilitados (volveremos sobre esto más adelante);
- observe los tipos predeterminados: [longtext] para una cadena (texto de cualquier longitud) y [decimal(65,30)] para un [decimal] (65 dígitos, 30 de ellos después del punto decimal). Rara vez son los que queremos: el párrafo siguiente muestra cómo especificarlos;
- líneas 21–41: [SaveChanges] envió un único comando que contiene tres comandos [INSERT] parametrizados. Cada uno va seguido de un [SELECT] que lee de nuevo la clave primaria generada por MySQL ([LAST_INSERT_ID()]): EF Core la copia en la propiedad [Id] del objeto insertado. Los valores de los parámetros están enmascarados ('?'): son datos de la aplicación, que pueden ser confidenciales. Durante la depuración, pueden mostrarse agregando la opción [.EnableSensitiveDataLogging()] a la configuración del contexto;
- líneas 42–50: la consulta LINQ [context.Articles.OrderBy(a => a.Name)] se tradujo en un comando [SELECT ... ORDER BY]. EF Core creó un objeto [Article] por cada fila leída.
No escribimos ningún comando SQL ni ningún código de lectura de columnas: ese es todo el sentido de un ORM. También vemos que esto no elimina la necesidad de comprender SQL: para determinar si el SQL generado es correcto y eficaz, hay que saber leerlo.
11.3. El modelo
EF Core construye su modelo a partir de las entidades en tres pasos:
- primero, aplica sus convenciones;
- las complementa o corrige mediante las anotaciones (atributos) aplicadas a las entidades;
- por último, aplica la configuración escrita en C# en el método [OnModelCreating] del contexto: la API fluida.
11.3.1. Las convenciones
Vimos lo esencial de ellas en el primer ejemplo:
- toda propiedad pública con un getter [get] y un setter [set] (o [init]) se almacena en una columna del mismo nombre;
- la propiedad [Id] o [<Entity>Id] es la clave primaria; si es un entero, sus valores los genera el SGBD;
- el nombre de la tabla es el de la propiedad [DbSet] del contexto (o, en su defecto, el de la clase);
- una propiedad de un tipo que admite valores nulos ([int?], [DateOnly?], [string?]) da lugar a una columna [NULL]; una propiedad de un tipo que no admite valores nulos ([int], [decimal], [string] cuando los tipos de referencia que admiten valores nulos están habilitados) da lugar a una columna [NOT NULL];
- una propiedad que hace referencia a otra entidad, o una colección de entidades, define una relación (la trataremos más adelante).
11.3.2. Anotaciones y API fluida
El proyecto [Model] define dos entidades configuradas de dos maneras diferentes. La primera se configura mediante anotaciones:
- líneas 1–2: los atributos utilizados pertenecen a estos dos espacios de nombres de .NET. No son específicos de EF Core: los atributos de validación ([Required], [MaxLength]) también se utilizan para validar datos en los formularios de ASP.NET Core;
- línea 7: el nombre de la tabla;
- líneas 11–12: la clave primaria no se llama [Id]; el atributo [Key] la identifica;
- líneas 15–16: una columna obligatoria ([Required]: [NOT NULL]) con un máximo de 50 caracteres ([MaxLength(50)]: [varchar(50)]). [Required] es redundante aquí, ya que el tipo [string] que no admite valores nulos basta para que la columna sea obligatoria; era esencial antes de C# 8;
- líneas 19–20: el tipo [string?] especifica una descripción opcional: la columna aceptará el valor [NULL];
- líneas 23–24: [Column] especifica el nombre de la columna y su tipo SQL: [decimal(10,2)], 10 dígitos, incluidos 2 decimales;
- línea 27: una fecha opcional. El tipo [DateOnly] (.NET 6) representa una fecha sin hora: Pomelo la asocia con el tipo SQL [date];
- líneas 30–31: [NotMapped] excluye una propiedad del modelo. Aquí es innecesario: una propiedad sin descriptor de acceso ([set]) no se registra. El atributo documenta la intención.
La segunda entidad no tiene atributos:
Se configura en el contexto mediante la API fluida:
- Línea 13: la base de datos [efmodel] nunca existirá: este contexto se utiliza únicamente para examinar el modelo, lo que no requiere una conexión (la versión del servidor se especifica de forma explícita);
- línea 18: el método [OnModelCreating] recibe un objeto [ModelBuilder] que sirve para describir el modelo. Se llama una sola vez por tipo de contexto: EF Core almacena el modelo en caché;
- línea 20: [Entity<Supplier>(...)] recibe una lambda que configura la entidad [Supplier]. Cada método devuelve el objeto de configuración, lo que permite encadenar las llamadas: de ahí el nombre “API fluida”;
- línea 22: el nombre de la tabla;
- línea 23: la clave primaria es la propiedad [Number];
- línea 24: una columna obligatoria con un máximo de 60 caracteres;
- línea 25: un índice único sobre el nombre de la empresa: dos proveedores no pueden tener el mismo. No existe un atributo de validación equivalente; EF Core proporciona el atributo [Index], colocado en la clase, que utilizaremos para los artículos;
- línea 26: la propiedad [Phone] se almacena en la columna [tel];
- línea 27: la columna [CreationDate] tiene un valor predeterminado, calculado por el SGBD. Durante una inserción, EF Core no enviará un valor para esta columna si la propiedad tiene el valor predeterminado de su tipo, lo que permitirá al SGBD utilizar [CURRENT_TIMESTAMP].
Todo lo que hacen las anotaciones puede hacerse con la API fluida, y la API fluida permite incluso más (índices, valores predeterminados, claves compuestas, relaciones complejas). Las anotaciones tienen la ventaja de colocar la configuración junto a la propiedad; la API fluida permite que las entidades sigan siendo independientes de EF Core y concentra la configuración en un único lugar. A menudo se combinan ambas: en caso de conflicto, prevalece la API fluida.
El programa [Program.cs] muestra el modelo construido por EF Core, seguido del script SQL que crearía las tablas:
- línea 8: la propiedad [Model] del contexto da acceso al modelo: sus entidades ([IEntityType]) y, para cada una, sus propiedades ([IProperty]);
- línea 10: [ClrType] es el tipo C# de la entidad, y [GetTableName()] es el nombre de su tabla;
- líneas 13–15: para cada propiedad, se muestran el nombre de la columna, su tipo SQL, si acepta el valor [NULL], y si forma parte de la clave primaria;
- línea 22: [Database.GenerateCreateScript()] devuelve el script SQL de creación de tablas sin ejecutarlo. Es el script que [EnsureCreated] ejecutaría.
Resultados:
- líneas 8–12: la entidad [Supplier] y sus columnas. Los tipos SQL provienen de la configuración ([varchar(60)], [varchar(20)]) o de las decisiones del proveedor para un tipo C#: [int] para [int], [datetime(6)] (precisión de microsegundos) para [DateTime];
- líneas 2–7: la entidad [Product]. Las propiedades que admiten valores nulos ([DateOnly?], [string?]) dan lugar a columnas [NULL]; la propiedad [PriceInclTax] no aparece en el modelo;
- líneas 16–33: el script de creación. Contiene toda la configuración: nombres de tablas y columnas, tipos de datos ([NOT NULL]), valores predeterminados, claves primarias (con [AUTO_INCREMENT] para las claves enteras) e índices únicos. Las columnas de texto utilizan el conjunto de caracteres [utf8mb4].
11.3.3. Tipos que admiten valores nulos y columnas NULL
Los tipos de referencia que admiten valores nulos (C# 8, habilitados mediante [<Nullable>enable</Nullable>] en los proyectos del curso) tienen un impacto en el modelo: EF Core lee las anotaciones de nulabilidad generadas por el compilador. Una propiedad [string] da lugar a una columna [NOT NULL], y una propiedad [string?] da lugar a una columna [NULL]. En un proyecto donde los tipos que admiten valores nulos no están habilitados, todas las columnas de texto aceptan [NULL], salvo las marcadas con [Required].
Por lo tanto, hay que elegir con cuidado el tipo de cada propiedad: expresa a la vez una regla del código C# (“este valor puede faltar”) y una restricción de la base de datos. Para una propiedad obligatoria, son comunes dos notaciones:
La segunda es más segura: el compilador rechaza [new Article { Price = 10 }], donde se ha omitido el nombre. EF Core puede crear entidades con miembros [required]: no pasa por el inicializador de objetos del código C#. Para las propiedades de navegación hacia otra entidad, que EF Core rellena por sí mismo, nos encontramos con la notación [= null!]: la veremos al tratar las relaciones.
11.4. Los ejemplos siguientes: dos bibliotecas compartidas
Los ejemplos de los párrafos siguientes utilizan todos la base de datos [efarticles] y su tabla [articles], poblada con los seis artículos del Capítulo 10. En lugar de repetir la entidad y el contexto en cada proyecto, los colocamos en una biblioteca de clases, [Articles.Data], a la que hacen referencia los proyectos. También reemplazamos el registro de EF Core, demasiado detallado para nuestros ejemplos, por un registro más compacto, colocado en una segunda biblioteca, [Ef.Tools].
11.4.1. El registro SQL compacto
- líneas 12–15: un miembro de extensión (C# 14, véase el Capítulo 4) del tipo [DbContextOptionsBuilder], el tipo del parámetro de [OnConfiguring]. Escribiremos [options.UseMySql(...).WithSqlLog()], como si el método hubiera sido escrito por EF Core. Llama a otra sobrecarga de [LogTo], que recibe dos funciones: un filtro, que selecciona los eventos que se registrarán, y un método de visualización, que recibe el propio evento ([EventData]) en lugar de texto preformateado;
- líneas 19–22: los eventos seleccionados. Cada evento de EF Core tiene un identificador; los de las operaciones relacionales son constantes de la clase [RelationalEventId]. Registramos los comandos SQL ejecutados o fallidos, así como el inicio, la confirmación (commit) y la reversión (rollback) de las transacciones;
- líneas 27–43: cada tipo de evento corresponde a una clase derivada de [EventData], que proporciona detalles sobre él: [CommandExecutedEventData] contiene el comando ADO.NET ejecutado ([DbCommand], véase el Capítulo 10). La selección se realiza mediante un [switch] con filtrado por patrón de tipo y cláusulas [when];
- líneas 52–54: el texto del comando, línea por línea, con sangría y precedido de [SQL>], con las líneas vacías eliminadas;
- líneas 56–60: los parámetros del comando y sus valores. Los leemos directamente del comando; por lo tanto, nuestro registro siempre los muestra, mientras que el registro de EF Core los oculta de forma predeterminada. Esto es aceptable para un curso, pero no para una aplicación en producción.
11.4.2. La entidad y el contexto de los artículos
La entidad [Article] de la biblioteca [Articles.Data] utiliza las anotaciones del párrafo anterior:
- línea 8: la tabla se llama [articles], como en el Capítulo 10;
- línea 9: el atributo [Index] de EF Core (espacio de nombres [Microsoft.EntityFrameworkCore]) crea un índice único sobre la columna [Name]: dos artículos no pueden tener el mismo nombre, como en la base de datos del curso de 2008;
- líneas 16–17: un nombre obligatorio de no más de 30 caracteres. El miembro es [required]: el código que crea un artículo debe especificar su nombre;
- líneas 20–21: un precio en [decimal(10,2)].
El contexto es el siguiente:
- líneas 10–11: la cadena de conexión y la versión del servidor, que son públicas para que otros proyectos puedan utilizarlas;
- línea 14: un primer constructor, sin parámetros: la configuración la gestionará [OnConfiguring];
- línea 17: un segundo constructor, que recibe un objeto preconfigurado ([DbContextOptions<ArticlesContext>]) y lo pasa al constructor de la clase [DbContext]. Este es el constructor que utiliza la inyección de dependencias (la veremos más adelante);
- línea 25: [OnConfiguring] se llama en ambos casos. [IsConfigured] comprueba si el contexto recibió una configuración mediante su constructor. Si no, se utiliza la configuración predeterminada: MySQL, con el registro compacto;
- líneas 33–48: un método estático que vuelve a crear la base de datos con sus seis artículos. Crea un contexto con una configuración que no incluye un registro: no queremos ver el SQL de esta inicialización en los resultados de los ejemplos. [DbContextOptionsBuilder<T>] es la versión genérica del objeto que recibe [OnConfiguring]; su propiedad [Options] devuelve la configuración construida. [AddRange] agrega varias entidades a la vez.
Los proyectos de ejemplo hacen referencia a la biblioteca [Articles.Data], que a su vez hace referencia a [Ef.Tools]:
Los paquetes de EF Core y Pomelo, a los que hace referencia [Articles.Data], son heredados por los proyectos que hacen referencia a ella.
11.5. Operaciones básicas: agregar, leer, modificar, eliminar
11.5.1. El programa [Crud]
El proyecto [Crud] muestra las cuatro operaciones básicas (CRUD: Create, Read, Update, Delete):
Resultados:
Comentarios:
- línea 10: [Find(1)] busca el registro con clave primaria 1. El tipo devuelto es [Article?]: [Find] devuelve [null] si la clave no existe. El SQL generado (líneas 2–7) es un [SELECT] parametrizado, limitado a una fila;
- línea 13: la segunda llamada a [Find(1)] no envía ningún comando SQL y devuelve el mismo objeto (línea 10). El contexto almacena las entidades que ha leído o agregado: antes de consultar la base de datos, [Find] comprueba si la entidad solicitada ya está bajo seguimiento. Un contexto nunca contiene dos objetos para la misma fila de la base de datos;
- líneas 18–19: agregar un artículo. Antes de [SaveChanges], el artículo está en el estado [Added] y su valor [Id] es 0 (línea 12). [SaveChanges] envía un comando [INSERT], recupera la clave generada y la coloca en [x.Id] (línea 21). El artículo pasa al estado [Unchanged]: es idéntico a la fila de la base de datos;
- línea 26: para modificar una fila de la base de datos, basta con modificar el objeto. No se requiere ningún método [Update]: el contexto ha conservado una copia de los valores leídos (los valores originales) y compara con ellos los valores actuales. El artículo pasa al estado [Modified] (línea 23);
- línea 27: [context.Entry(x)] da acceso a la información de seguimiento de la entidad [x]: su estado ([State]) y, para cada propiedad, su valor original ([OriginalValue]) y su valor actual ([CurrentValue]);
- línea 29: el comando [UPDATE] generado (líneas 25–28) modifica únicamente la columna que ha cambiado, [Price]. Le sigue un [SELECT ROW_COUNT()]: EF Core verifica que el comando haya modificado efectivamente una fila;
- líneas 34–36: la eliminación. [Remove] cambia el estado del artículo a [Deleted]; [SaveChanges] envía el comando [DELETE]. A partir de entonces, el contexto ya no sigue al objeto: está en el estado [Detached];
- líneas 41–43: el objeto [context.ChangeTracker] (el “seguimiento de cambios”) administra las entidades bajo seguimiento. [DetectChanges] compara los valores actuales de las entidades con sus valores originales (EF Core lo llama automáticamente en [SaveChanges], [Entry], y algunos otros métodos). La propiedad [DebugView.LongView] devuelve una descripción de todas las entidades bajo seguimiento (líneas 38–44): el contexto ahora sigue únicamente la bicicleta, cuyo inventario ha disminuido de 10 a 9. El operador [!] en [bike!] indica al compilador que [bike], de tipo [Article?], no es [null] en este punto.
Dos detalles del SQL generado por Pomelo:
- el comando [INSERT], seguido de un [SELECT] de la clave generada, está encerrado dentro de una transacción (líneas 13–20): el comando contiene dos comandos SQL que deben tener éxito juntos. Volveremos sobre las transacciones más adelante;
- los comandos aislados [UPDATE] y [DELETE] no están encerrados dentro de una transacción. Van precedidos de [SET AUTOCOMMIT = 1], un ajuste de sesión de MySQL (cada comando se confirma en cuanto se ejecuta) que el proveedor restablece como precaución. Este ajuste no tiene efecto sobre una transacción abierta de forma explícita, como veremos.
11.5.2. Los estados de una entidad
El seguimiento de cambios se basa en el estado de cada entidad, un valor de la enumeración [EntityState]:
Estado | Significado |
[Detached] | El contexto no sigue al objeto (creado con [new] y aún no agregado, o eliminado de la base de datos) |
[Added] | El objeto se ha agregado al contexto ([Add]): [SaveChanges] lo insertará en la base de datos |
[Unchanged] | El objeto se leyó de la base de datos (o se guardó) y no se ha modificado desde entonces |
[Modified] | Se ha modificado al menos una propiedad: [SaveChanges] enviará un comando [UPDATE] |
[Deleted] | El objeto se ha marcado para su eliminación ([Remove]): [SaveChanges] enviará un comando [DELETE] |
Observe el ciclo de trabajo con EF Core: se leen entidades, se modifican como objetos ordinarios, se agregan y se eliminan, y luego se llama a [SaveChanges], que envía todos los comandos necesarios a la base de datos en un solo lote. El contexto actúa como una “unidad de trabajo”. Un contexto es un objeto ligero diseñado para tener una vida corta: una unidad de trabajo, como una solicitud HTTP en una aplicación web. No se utiliza el mismo contexto durante toda la vida de una aplicación, ya que acumularía entidades bajo seguimiento.
11.5.3. Actualizaciones masivas y lectura sin seguimiento
El seguimiento de cambios tiene un costo: para aumentar el precio de 100 artículos, hay que leer los 100 artículos, modificarlos uno por uno, y [SaveChanges] enviará 100 comandos [UPDATE]. EF Core 7 introdujo dos métodos que envían directamente un comando SQL que abarca todas las filas seleccionadas por una consulta: [ExecuteUpdate] y [ExecuteDelete]. El proyecto [BulkUpdate] los describe, así como las operaciones de solo lectura:
Resultados:
Comentarios:
- Líneas 10–12: [ExecuteUpdate] se aplica a una consulta ([Where]) y recibe una lambda que describe las columnas que se van a modificar: [SetProperty(property, new value)]. El nuevo valor puede depender de la propia fila ([a => a.MinimumStock * 2]). La instrucción SQL (líneas 3–5) se ejecuta de inmediato, sin [SaveChanges], y devuelve el número de filas modificadas;
- líneas 16–18: un aumento del 10 % en los precios bajos. Observe que las constantes del código C# ([150], [1.1M]) se escriben dentro del texto del comando SQL ([150.0], [1.1]);
- línea 23: [ExecuteDelete] elimina las filas seleccionadas por la consulta —en este caso, el arco, el único artículo con un precio superior a 550 euros—;
- línea 28: [AsNoTracking()] solicita una lectura sin seguimiento: el contexto no almacena las entidades leídas (línea 26). Esto es más rápido y consume menos memoria: se utiliza para datos que se leen sin modificarse (visualización, cálculos). La contrapartida es que [SaveChanges] ignora los cambios realizados en estas entidades (línea 27);
- líneas 37–41: una trampa. [ExecuteUpdate] opera directamente sobre la base de datos: no modifica las entidades ya cargadas por el contexto. La bicicleta que sigue el contexto conserva su precio anterior (línea 37) hasta que se vuelve a leer con [context.Entry(bike).Reload()]. [Single] devuelve el único elemento de la consulta y lanza una excepción si hay cero o más de un elemento: por eso el SQL generado solicita dos filas ([LIMIT 2]).
11.6. LINQ se traduce a SQL
11.6.1. Consultas
El Capítulo 5 presentó LINQ para colecciones en memoria. Los mismos operadores ([Where], [OrderBy], [Select], [First], [Count], [Sum]...) se aplican a un [DbSet<T>], pero .NET no los ejecuta: EF Core los traduce a SQL y es el SGBD quien los ejecuta. El proyecto [Linq] ofrece varios ejemplos:
Resultados:
Comentarios:
- Líneas 10–13: [Where] y [OrderBy] se convierten en las cláusulas [WHERE] y [ORDER BY] (líneas 5–6). La consulta solo se ejecuta cuando se solicitan sus resultados, en este caso mediante [ToList]: esta es la ejecución diferida de LINQ (Capítulo 5);
- líneas 18–20: una proyección. [Select] crea un objeto de tipo anónimo para cada artículo, que contiene solo el nombre y el valor del inventario. El SQL generado (línea 9) recupera únicamente las columnas pertinentes y realiza el cálculo por sí mismo. Los objetos del tipo anónimo no son entidades: el contexto no los sigue. El proveedor convierte las existencias, que son un entero, a [decimal(65,30)] antes de la multiplicación, lo que explica los numerosos decimales del resultado, que luego se formatea con [{v.Value:0.00}];
- línea 30: [FirstOrDefault] se convierte en [LIMIT 1]. La variable del programa [minPrice] se convierte en un parámetro del comando SQL ([@__minPrice_0], línea 21), mientras que una constante escrita en la lambda se copia en el texto SQL. Por lo tanto, no hay que preocuparse por las inyecciones SQL: los valores que provienen del exterior del programa siempre se pasan como parámetros. Es la regla que el Capítulo 10 aplicó manualmente con consultas parametrizadas;
- líneas 35–36: los agregados [Count] y [Sum] los calcula el SGBD ([COUNT(*)], [SUM(...)]): solo se transfiere el resultado, no las filas. [COALESCE(..., 0.0)] devuelve 0 si la tabla está vacía, igual que [Sum] de LINQ;
- líneas 42–45: los métodos de .NET que EF Core conoce se traducen a SQL: [a.Name.StartsWith("b")] se convierte en [LIKE 'b%'], y [names.Contains(a.Name)], que hace referencia a una lista en memoria, se convierte en [IN ('bow', 'pump', 'racket')] (línea 35). Hay muchos métodos traducidos: operaciones sobre cadenas, fechas y funciones matemáticas;
- líneas 51–52: [ToQueryString()] devuelve el texto SQL de una consulta sin ejecutarla (líneas 37–41). Es útil para la depuración;
- líneas 57–60: la paginación, para mostrar una lista larga página por página. [Skip] omite los artículos de las páginas anteriores, mientras que [Take] conserva los de la página solicitada: se convierten en las cláusulas [OFFSET] y [LIMIT] (línea 46). La paginación solo tiene sentido sobre una lista ordenada ([OrderBy]);
- línea 61: esta proyección contiene una cadena interpolada, que EF Core no traduce a SQL. Esto no es un error: cuando la operación no traducible es el [Select] final, EF Core solicita al SGBD las columnas necesarias ([Name] y [Price]) y realiza la proyección en memoria sobre cada fila leída. Observe que el precio se formatea según la configuración regional en-US, con un punto decimal;
- líneas 69–71: EF Core no puede traducir la llamada a ningún método del programa: no conoce su código y, aunque lo conociera, no necesariamente sabría cómo escribirlo en SQL. Ejecutar la consulta desencadena una [InvalidOperationException] (líneas 50–51). El mensaje (en inglés, como todos los mensajes de excepción de .NET), del cual el programa muestra solo la primera oración, ofrece entonces dos soluciones: reescribir la consulta o pasar explícitamente a una evaluación en memoria;
- línea 78: [AsEnumerable()] transfiere la consulta de [IQueryable<T>] a [IEnumerable<T>]: la parte anterior se traduce a SQL (aquí, la lectura de toda la tabla) y la parte siguiente la ejecuta LINQ en memoria. El resultado es correcto, pero se cargó toda la tabla: con una tabla grande, esto debe evitarse. Es mejor escribir la condición en la lambda ([a.CurrentStock < a.MinimumStock]), como se muestra en la línea 11.
11.6.2. IQueryable y árboles de expresión
¿Cómo puede ejecutarse la misma lambda en C# sobre una lista y traducirse a SQL sobre un [DbSet]? El Capítulo 7 dio la respuesta: un [DbSet<T>] implementa la interfaz [IQueryable<T>], cuyos métodos [Where], [OrderBy], [Select]... no reciben delegados ([Func<T, bool>]) sino árboles de expresión ([Expression<Func<T, bool>>]). El compilador transforma la lambda [a => a.CurrentStock < a.MinimumStock] en una estructura de datos que la describe (“ comparación [<] de la propiedad [CurrentStock] y la propiedad [MinimumStock] del parámetro [a]”); EF Core recorre esta estructura y produce el SQL equivalente. Un método como [Rules.OutOfStock] aparece en el árbol solo como una llamada a método, cuyo código no puede analizarse: de ahí el error.
Los operadores se componen: una consulta puede construirse por etapas, devolviendo cada etapa un nuevo [IQueryable<T>], y solo la ejecución final ([ToList], [First], [Count], [foreach]...) envía un comando SQL:
11.6.3. Una incompatibilidad entre EF Core 9 y C# 14
En el programa [Linq], la lista [names] se declaró de tipo [List<string>] en lugar de [string[]], con un comentario que hace referencia a este párrafo. Con un arreglo, la consulta [context.Articles.Where(a => names.Contains(a.Name))] se compila, pero falla en tiempo de ejecución con un error [InvalidOperationException] (“An exception was thrown while attempting to evaluate a LINQ query parameter expression”). En efecto, C# 14 ha convertido la conversión de un arreglo a [ReadOnlySpan<T>] (el tipo presentado en el Capítulo 5) en una conversión implícita del lenguaje, que se aplica también al objeto sobre el que se llama a un método de extensión. Para un arreglo, la llamada [names.Contains(...)] ahora hace referencia, por lo tanto, al método de extensión [MemoryExtensions.Contains(ReadOnlySpan<T>, T)] en lugar de a [Enumerable.Contains(IEnumerable<T>, T)]: esto se evidencia al examinar el árbol de expresión de la lambda, y el mismo programa compilado en C# 13 ([<LangVersion>13</LangVersion>]) encuentra [Enumerable.Contains] y funciona. EF Core 9, publicado antes que C# 14, no reconoce este método: intenta evaluar la conversión del arreglo a [ReadOnlySpan<string>] para convertirla en un parámetro SQL, lo que falla (la excepción interna es una [ArgumentException] lanzada por el intérprete de árboles de expresión). EF Core 10, publicado junto con C# 14, admite esta sintaxis. Con EF Core 9, se puede sortear el problema utilizando una lista, como se muestra aquí, o escribiendo [((IEnumerable<string>)names).Contains(a.Name)]. Este es el único problema encontrado en este capítulo al usar EF Core 9 con .NET 10.
11.7. Relaciones
11.7.1. El modelo de la tienda
Las tablas de una base de datos están vinculadas entre sí. EF Core representa estos vínculos mediante propiedades de navegación: propiedades que hacen referencia a otra entidad o a una colección de entidades. El proyecto [Relations] utiliza una base de datos [efshop] que describe una pequeña tienda:
- una relación de uno a muchos entre [Category] y [Product]: una categoría contiene varios productos (línea 9) y un producto pertenece a una categoría (líneas 19–20). La propiedad [CategoryId] es la clave externa: por convención, el nombre de la propiedad de navegación seguido de [Id]. Es opcional en el código (EF Core la crearía en la tabla si no existiera en la clase), pero resulta cómoda: permite determinar la categoría de un producto sin cargarla;
- una relación de muchos a muchos entre [Product] y [Tag]: un producto tiene varias etiquetas (línea 22) y una etiqueta está asociada a varios productos (línea 30). No hay clave externa: la relación se almacenará en una tabla de asociación creada por EF Core;
- las relaciones de uno a muchos [Client] - [Order] y [Order] - [OrderLine], y la relación de muchos a uno [OrderLine] - [Product]: una línea de pedido representa una cantidad de un producto;
- las colecciones se inicializan con una colección vacía ([= []], una expresión de colección de C# 12). Las propiedades de navegación que apuntan a una sola entidad se inicializan con [null!]: el valor [null], acompañado del operador [!], que indica al compilador que no señale que una propiedad que no admite valores nulos recibe [null]. Esta es la notación convencional para una propiedad que EF Core rellena por sí mismo durante las operaciones de lectura y que nunca es [null] en una entidad cargada correctamente. Una propiedad de este tipo define una relación obligatoria (clave externa [NOT NULL]); una propiedad de tipo [Category?] y una clave de tipo [int?] definirían una relación opcional.
El contexto es el siguiente:
- línea 7: el contexto tiene un constructor primario (C# 12) cuyo parámetro opcional [log] permite omitir el SQL;
- líneas 9–13: cinco [DbSet]. Una entidad no necesita un [DbSet] para formar parte del modelo: [OrderLine], a la que se llega mediante la propiedad de navegación [Order.Lines], forma parte de él de hecho;
- línea 19: el registro compacto se agrega si se solicita;
- línea 28: la API fluida establece la precisión del precio.
Las tablas creadas por [EnsureCreated] son las siguientes:
- Líneas 5–11: una tabla por entidad. La tabla [OrderLine] lleva el nombre de la clase, al no existir la propiedad [DbSet]; la tabla [ProductTag] es la tabla de asociación de la relación de muchos a muchos;
- Línea 22: la clave externa [CategoryId] de la tabla [Products] hace referencia a la tabla [Categories]. La opción [ON DELETE CASCADE] elimina los productos de una categoría cuando esta se elimina: este es el comportamiento predeterminado de EF Core para una relación obligatoria. EF Core también crea un índice sobre cada clave externa (línea 21);
- líneas 26–32: la tabla de asociación tiene dos columnas, claves externas hacia las dos tablas vinculadas, que juntas forman su clave primaria;
- línea 17: no hemos limitado la longitud de los nombres, de ahí el tipo [longtext].
11.7.2. El programa
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 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 | |
Resultados:
Comentarios:
- Líneas 13–32: se agregan tres categorías, junto con sus productos y las etiquetas de los productos: un grafo de objetos. EF Core recorre las propiedades de navegación y agrega al contexto todas las entidades que encuentra. [SaveChanges] las inserta en el orden correcto (las categorías antes de los productos que hacen referencia a ellas) y rellena las claves externas y la tabla de asociación. Esta inicialización se realiza sin registro;
- líneas 35–36: la propiedad [Local] de un [DbSet] da acceso a las entidades que el contexto ya sigue, sin consultar la base de datos;
- líneas 56–71: un cliente, su pedido y las dos líneas del pedido se agregan en una sola llamada a [Add]. El SQL (líneas 11–35) muestra el orden de las inserciones: el cliente, luego el pedido —cuya clave externa ([ClientId]) recibe la clave generada para el cliente ([@p1=2])— y, por último, las líneas del pedido, cuya clave externa ([OrderId]) recibe la clave del pedido;
- líneas 79–80: de forma predeterminada, EF Core carga solo la entidad solicitada. Las propiedades de navegación [Client] y [Lines] del pedido leído no se rellenaron (línea 41): [Client] es igual a [null] (a pesar de la declaración que no admite valores nulos, de ahí el operador [?.]), y la lista de líneas está vacía. EF Core admite la carga diferida (lazy loading): la propiedad de navegación se carga automáticamente en su primera lectura. Debe habilitarse explícitamente (paquete [Microsoft.EntityFrameworkCore.Proxies], propiedades de navegación [virtual]); no la utilizamos porque oculta los accesos a la base de datos;
- líneas 87–89: carga anticipada (eager loading). [Include(c => c.Client)] indica al sistema que cargue el cliente de cada pedido; [Include(c => c.Lines)] carga las líneas del pedido, y [ThenInclude(l => l.Product)] carga el producto de cada línea. Todo se carga mediante una sola consulta [SELECT], con combinaciones (joins) (líneas 45–51). La salida muestra ambos pedidos y sus líneas;
- línea 106: la carga explícita. Cargamos la colección de productos de una categoría que ya se ha leído: una segunda consulta, [SELECT], lee los productos cuya clave externa coincide con la de la categoría. Para una propiedad de navegación hacia una sola entidad, escribimos [context.Entry(product).Reference(p => p.Category).Load()];
- líneas 114–116: las propiedades de navegación se utilizan en consultas LINQ, sin [Include]: [p.Tags.Any(...)] se convierte en una subconsulta [EXISTS] sobre la tabla de asociación (líneas 72–76), y [p.Category.Name] se convierte en una combinación (join);
- líneas 125–126: un cálculo a través de dos relaciones —el importe de cada pedido— realizado íntegramente por el SGBD mediante una subconsulta (líneas 81–84);
- líneas 135–138: una agrupación. [GroupBy] agrupa los productos por nombre de categoría; para cada grupo ([g]), el SGBD calcula la clave ([g.Key]), el número de productos ([Count]) y el precio promedio ([Average]): la consulta se convierte en un [GROUP BY] (líneas 90–93). La categoría [diving], que no tiene productos, no aparece: la combinación con la tabla de categorías es una combinación interna ([INNER JOIN]).
El llamado problema de las “consultas N+1” es un riesgo para cualquier usuario de un ORM. Supongamos que queremos mostrar el nombre del cliente de cada pedido y leemos los pedidos sin [Include], y luego recuperamos el cliente de cada uno mediante una carga explícita (o una carga diferida, que equivale a lo mismo sin que nos demos cuenta): ejecutamos una consulta para los N pedidos y luego N consultas, una por pedido. Con mil pedidos, esto da como resultado mil un viajes de ida y vuelta al servidor, cuando uno solo habría bastado. Las soluciones son las que se muestran en el ejemplo: [Include] o, mejor aún, una proyección ([Select]) que recupere únicamente los datos pertinentes. El registro SQL ayuda a identificar el problema: la misma consulta repetida numerosas veces.
11.8. Migraciones
11.8.1. El principio
Hasta ahora, la base de datos se ha creado con [EnsureCreated], tras ser eliminada con [EnsureDeleted]. Esto es imposible en una aplicación en producción: su base de datos contiene datos que deben conservarse cuando el modelo evoluciona (una nueva columna, una nueva tabla). Además, [EnsureCreated] solo puede crear una base de datos que no existe: si la base de datos ya existe con tablas, no hace nada, aunque el modelo haya cambiado.
Las migraciones responden a esta necesidad. Una migración es una clase C#, generada por la herramienta [dotnet ef], que describe la transición de una versión del modelo a la siguiente: su método [Up] aplica el cambio (crear una tabla, agregar una columna), mientras que su método [Down] lo revierte. La base de datos contiene una tabla llamada [__EFMigrationsHistory], en la que EF Core registra las migraciones que se le han aplicado; esto le permite saber cuáles faltan por aplicar.
11.8.2. El proyecto
El proyecto [Clients] utiliza la base de datos [efclients]. Su archivo de proyecto agrega el paquete [Microsoft.EntityFrameworkCore.Design], que requiere la herramienta [dotnet ef]:
- Líneas 15–18: el elemento [PrivateAssets] (“all”) indica que este paquete está destinado únicamente al desarrollo: no se distribuye a los proyectos que hacen referencia a este y no es necesario para la ejecución. Esto es lo que produce el comando [dotnet add package Microsoft.EntityFrameworkCore.Design].
La entidad es un cliente:
En la primera versión de la aplicación, el cliente no tiene número de teléfono: las líneas 13–14 todavía no existen. Las agregaremos en la segunda versión.
La herramienta [dotnet ef] debe poder crear un contexto para determinar el modelo y, para ciertos comandos, conectarse a la base de datos. Para ello utiliza, en orden: una clase del proyecto que implemente la interfaz [IDesignTimeDbContextFactory<T>], o el contenedor de inyección de dependencias de una aplicación ASP.NET Core o, en su defecto, un constructor sin parámetros del contexto. Escribimos una fábrica:
- línea 7: el contexto recibe su configuración mediante un constructor primario (C# 12), que pasa al constructor de [DbContext]. No tiene un método [OnConfiguring]: no conoce su base de datos; el código que lo crea la elige;
- Líneas 13–21: la fábrica. Su método [CreateDbContext] construye la configuración ([DbContextOptionsBuilder<T>]) y crea el contexto. El parámetro [args] recibe los argumentos que se pasan a la herramienta; no lo usamos.
11.8.3. La primera migración
Los comandos de la herramienta [dotnet ef] se escriben en la carpeta del proyecto. La primera migración, que llamamos [Initial], se crea con el comando [dotnet ef migrations add]:
La herramienta compiló el proyecto, creó un contexto con la fábrica, comparó el modelo con el de la última migración (todavía no hay ninguna) y generó tres archivos en una carpeta llamada [Migrations]:
Los nombres de los archivos comienzan con la fecha y la hora de creación de la migración (año, mes, día, hora, minuto, segundo): las migraciones se aplican en ese orden. El archivo [ClientsContextModelSnapshot.cs] contiene una descripción de el modelo tal como queda después de la última migración: la herramienta usa este archivo para compararlo con el modelo actual y así generar la siguiente migración. Estos archivos forman parte del código fuente de la aplicación: se almacenan y gestionan junto con el resto del código (por ejemplo, en un repositorio Git).
La migración generada es la siguiente:
- línea 9: una migración deriva de la clase [Migration];
- líneas 12–32: el método [Up] describe las operaciones que se deben realizar, mediante un objeto [MigrationBuilder]: modificar el juego de caracteres de la base de datos ([AlterDatabase]), crear la tabla [Clients] ([CreateTable]) con sus columnas y su clave primaria. Las anotaciones [MySql:...] contienen información específica del proveedor Pomelo;
- líneas 36–39: el método [Down] revierte la migración eliminando la tabla.
El código de una migración puede modificarse manualmente, por ejemplo, para agregar operaciones que la herramienta no puede deducir del modelo ([migrationBuilder.Sql("...")] ejecuta cualquier comando SQL).
11.8.4. Aplicar una migración
El comando [dotnet ef database update] aplica a la base de datos las migraciones que todavía no se han aplicado o, si se le da el nombre de una migración, todas las migraciones hasta esa inclusive:
La base de datos [efclients] no existía: se creó. El cliente [mysql] de MySQL muestra sus tablas:
Contiene la tabla del modelo [Clients] y la tabla [__EFMigrationsHistory], que contiene una fila por cada migración aplicada.
11.8.5. Una segunda migración
La aplicación evoluciona: la propiedad [Phone], de tipo [string?] y limitada a 20 caracteres, se agrega a la entidad [Client] (esta es la versión del archivo [Client.cs] mostrada anteriormente). Se crea una nueva migración:
La herramienta comparó el modelo actual con la instantánea y generó la siguiente migración:
- Líneas 13–18: [Up] agrega la columna [Phone], que es opcional puesto que la propiedad es de tipo [string?]. A las filas existentes de la tabla se les asignará el valor [NULL]. Si la propiedad hubiera sido obligatoria ([string]), habría sido necesario asignar un valor a las filas existentes: la migración lo habría hecho con la cadena vacía, que es el valor predeterminado de la columna ([defaultValue: ""]);
- líneas 25–27: [Down] elimina la columna.
La instantánea del modelo también se actualizó. Estos son los cambios principales:
- línea 12: el atributo [DbContext] asocia la instantánea con el contexto [ClientsContext];
- líneas 24–48: la descripción de la entidad [Client], escrita con la API fluida: cada propiedad, su tipo SQL, su longitud, su carácter obligatorio ([IsRequired]), la clave primaria y la tabla. La propiedad [Phone] está incluida aquí (líneas 42–44). Al comparar este modelo con el modelo actual del código, la herramienta determinará las operaciones de la siguiente migración. Este archivo nunca debe modificarse manualmente; para deshacer la última migración (si no se ha aplicado), use [dotnet ef migrations remove], que elimina sus archivos y restaura la instantánea a su estado anterior.
El comando [dotnet ef migrations list] enumera las migraciones del proyecto y las que todavía no se han aplicado a la base de datos:
El comando [dotnet ef migrations script] genera el script SQL de una migración (o de una serie de migraciones) sin ejecutarlo. Se usa cuando la base de datos de producción no la actualiza el desarrollador, sino un administrador que desea revisar y ejecutar por sí mismo el script SQL:
- Líneas 4–10: la migración se ejecuta dentro de una transacción: la modificación del esquema y la adición de la migración a la tabla de historial se completan o fallan juntas. Advertencia: en MySQL, un comando de modificación del esquema ([ALTER TABLE], [CREATE TABLE]) confirma implícitamente la transacción en curso. Si ocurre un error en medio de una migración, la base de datos puede quedar en un estado intermedio;
- Línea 7: la migración se registra en la tabla de historial, junto con la versión de EF Core que la aplicó.
11.8.6. Aplicar las migraciones desde la aplicación
Una aplicación también puede aplicar las migraciones por sí misma al iniciarse. Esto es lo que hace el programa del proyecto [Clients]:
- línea 5: el contexto se crea mediante la fábrica proporcionada por la herramienta;
- líneas 8–9: las migraciones aplicadas a la base de datos (leídas de la tabla de historial) y las que quedan por aplicar;
- línea 12: [Migrate] aplica las migraciones pendientes (creando la base de datos si es necesario). Esto equivale a [dotnet ef database update];
- Líneas 16–20: se usa la nueva columna.
Resultados:
El programa aplicó la segunda migración. La tabla de historial ahora contiene ambas migraciones:
Aplicar las migraciones al inicio es cómodo para una aplicación pequeña o durante el desarrollo. Para una aplicación grande desplegada en varios servidores, es preferible aplicarlas como un paso separado del proceso de despliegue (script SQL o ejecutable de migración generado por [dotnet ef migrations bundle]). Tenga en cuenta lo siguiente:
- [EnsureCreated]: para ejemplos, pruebas y prototipos, cuando la base de datos puede eliminarse y volver a crearse;
- migraciones: en cuanto la base de datos contiene datos que deben conservarse. No deben mezclarse: una base de datos creada con [EnsureCreated] no tiene tabla de historial, y no se le pueden aplicar migraciones.
11.9. Asincronía
Una consulta a la base de datos es una operación de E/S: mientras el servidor trabaja, el hilo que espera no hace nada. El capítulo 9 mostró cómo liberar este hilo mediante [async] y [await]. EF Core ofrece una versión asíncrona de todos los métodos que acceden a la base de datos: [ToListAsync], [FirstOrDefaultAsync], [SingleAsync], [CountAsync], [SumAsync], [FindAsync], [SaveChangesAsync], etc. Están definidos en el espacio de nombres [Microsoft.EntityFrameworkCore] (no en [System.Linq]). El proyecto [Async] los utiliza:
Resultados:
Comentarios:
- Línea 7: un [DbContext] implementa [IAsyncDisposable]: [await using] (C# 8, capítulo 9) lo libera de forma asíncrona;
- línea 11: [ToListAsync] ejecuta la consulta y devuelve un [Task<List<Article>>]. La consulta en sí ([Where], [OrderBy]) se escribe como antes: solo cambia el método que la ejecuta;
- líneas 14–15: las versiones asíncronas de [FirstOrDefault] y [Count];
- línea 21: el guardado asíncrono;
- línea 26: [AsAsyncEnumerable()] devuelve la consulta como un flujo asíncrono ([IAsyncEnumerable<T>], capítulo 9), que se recorre con [await foreach]. Las entidades se procesan a medida que se leen, sin formar una lista: esto es útil para procesar un gran número de filas;
- líneas 33–39: los métodos asíncronos aceptan un [CancellationToken] (capítulo 9). Aquí, el token se cancela antes de la llamada: [ToListAsync] lanza de inmediato una [OperationCanceledException] (línea 34). En una aplicación web, se pasa el token de la solicitud HTTP: si el cliente aborta la solicitud, la operación de lectura en curso se interrumpe.
Una regla importante: un contexto no es seguro para hilos y acepta solo una operación a la vez. No inicie dos solicitudes simultáneas en el mismo contexto (por ejemplo, con [Task.WhenAll]): hay que esperar ([await]) a que termine una operación antes de comenzar otra. EF Core suele detectar este error y lanza una [InvalidOperationException] («A second operation was started on this context instance before a previous operation completed»), pero no siempre. Para solicitudes realmente paralelas, se usa un contexto por tarea.
En una aplicación de consola como nuestros ejemplos, la asincronía no ofrece ningún beneficio visible. Resulta especialmente valiosa en una aplicación de servidor (capítulos 12 y 13), donde un hilo liberado durante una solicitud SQL puede atender a otros clientes. Por eso las aplicaciones ASP.NET Core usan sistemáticamente los métodos asíncronos de EF Core.
11.10. Transacciones y concurrencia
11.10.1. Transacciones
El capítulo 10 presentó las transacciones: un conjunto de operaciones que se completan todas o fallan todas. Con EF Core, hay dos puntos clave que tener en cuenta:
- [SaveChanges] es transaccional: si envía varios comandos, los ejecuta dentro de una transacción. Si alguno falla, ninguno se confirma, y [SaveChanges] lanza una [DbUpdateException];
- Para agrupar varias llamadas a [SaveChanges] (o comandos como [ExecuteUpdate], [ExecuteSql]...) en una sola transacción, se abre una transacción explícita con [context.Database.BeginTransaction()] (o su versión asíncrona), se confirma con [Commit] y se revierte con [Rollback].
El proyecto [Transactions] ilustra ambos casos:
Resultados:
Comentarios:
- Líneas 11–15: se agregan dos artículos, el segundo de los cuales tiene el mismo nombre que un artículo existente. [SaveChanges] abre una transacción (línea 3) y envía ambas instrucciones [INSERT]. La segunda viola el índice único de la columna [Name]: MySQL rechaza la inserción, y [SaveChanges] lanza una [DbUpdateException], cuya excepción interna es el error del SGBD (línea 15). La transacción no se confirmó: se abandona y MySQL revierte sus operaciones. La raqueta, que se había insertado correctamente, no está en la base de datos (línea 21);
- línea 29: una transacción explícita. El objeto devuelto ([IDbContextTransaction]) se libera con [await using]: si no se ha confirmado, la transacción se revierte en ese punto;
- Líneas 33–35: el primer [SaveChangesAsync] registra la venta de dos bicicletas. Como ya hay una transacción en curso, [SaveChanges] no inicia una nueva; en cambio, se incluye en la existente. El comando [SET AUTOCOMMIT = 1], que precede a [UPDATE] (línea 28), no confirma la transacción en curso: las líneas siguientes muestran que la venta efectivamente se cancelará;
- líneas 37–38: el segundo guardado falla (líneas 38–40);
- línea 40: nunca se llega a la confirmación;
- línea 46: en el [catch], la transacción se revierte (línea 41). La venta de las bicicletas, aunque registrada por el primer [SaveChangesAsync], se cancela: el inventario de bicicletas sigue en 10 (línea 47);
- Líneas 53–57: una función local asíncrona que vuelve a leer un artículo con un contexto nuevo para ver el estado real de la base de datos en lugar de las entidades rastreadas por el contexto de trabajo.
11.10.2. Concurrencia optimista
Dos usuarios leen el mismo artículo, que tiene un stock de 10. El primer usuario vende uno y actualiza el stock a 9. El segundo usuario, que leyó el stock antes de esta actualización, vende tres y actualiza el stock a 7: la venta del primer usuario se pierde. Este es el problema de las actualizaciones perdidas.
Una solución sería bloquear la fila durante toda la operación de cada usuario (concurrencia «pesimista»): esto bloquea a los demás usuarios, a veces durante mucho tiempo. EF Core implementa la concurrencia optimista: no se bloquea nada, pero en el momento de la confirmación, el sistema verifica que la fila no haya sido modificada desde que se leyó. Para ello, se designan una o más propiedades como tokens de concurrencia: EF Core agrega la condición «el token todavía tiene el valor leído» a la cláusula [WHERE] de las instrucciones [UPDATE] y [DELETE] . Si el comando no modifica ninguna fila, significa que otro usuario ya las procesó: EF Core lanza una [DbUpdateConcurrencyException].
El proyecto [Concurrency] convierte el stock en un token de concurrencia. En lugar de modificar la entidad [Article] compartida por los demás ejemplos, deriva el contexto y complementa el modelo con la API fluida:
- línea 11: se conserva la configuración de la clase padre;
- línea 13: la propiedad [CurrentStock] se convierte en un token de concurrencia. La anotación equivalente es el atributo [ConcurrencyCheck] aplicado a la propiedad.
El programa simula a los dos usuarios con dos contextos:
Resultados:
Comentarios:
- líneas 12–13: cada usuario lee la bicicleta en su propio contexto;
- líneas 17–18: el comando [UPDATE] del primer usuario contiene la condición [CurrentStock = @p2], con el valor leído, 10 (líneas 13–16). La fila se modifica;
- líneas 23–26: el comando del segundo usuario contiene la misma condición, con el valor que leyó, 10, mientras que el inventario en la base de datos ahora es 9. No se modifica ninguna fila: [SELECT ROW_COUNT()] devuelve 0, y EF Core lanza una [DbUpdateConcurrencyException] (línea 24);
- líneas 34–36: la propiedad [Entries] de la excepción enumera las entidades en conflicto. La resolución depende de la aplicación: abortar, advertir al usuario o, como aquí, volver a leer la entidad desde la base de datos ([Reload]) y repetir la operación. El inventario releído es 9 (línea 31), y la venta de las tres bicicletas da como resultado un inventario de 6, con la condición [CurrentStock = 9] (línea 36).
El token de concurrencia más común no son datos de negocio, sino una columna dedicada que se modifica con cada actualización de la fila: un número de versión o una fecha de modificación. En SQL Server, una propiedad de tipo [byte[]] marcada con el atributo [Timestamp] se asocia al tipo [rowversion], que el SGBD modifica automáticamente; en MySQL, a menudo se usa un entero o una fecha que la aplicación (o un trigger) modifica con cada actualización.
11.11. El SQL sin procesar
EF Core genera SQL a partir de LINQ, pero también es posible escribir uno mismo el SQL de una consulta, para usar una característica específica del SGBD o para optimizar una consulta compleja. El proyecto [RawSql] presenta los métodos disponibles:
Resultados:
Comentarios:
- Líneas 11–13: [FromSql] ejecuta una consulta SQL que devuelve filas de la tabla de una entidad e instancia entidades (rastreadas por el contexto). Su parámetro es una cadena interpolada: EF Core no la convierte en texto; en cambio, recibe un objeto [FormattableString] que contiene por separado el texto y los valores que se deben insertar, y convierte cada valor en un parámetro SQL ([@p0], línea 5). El resultado de [FromSql] es un [IQueryable<T>]: puede completarse con LINQ. La cláusula [OrderBy] fue agregada por EF Core alrededor de nuestra consulta, que se convirtió en una subconsulta;
- líneas 19–20: un intento de inyección SQL. El valor de [name] se pasa como parámetro: se compara tal cual con la columna [Name], y ningún registro coincide (línea 18);
- línea 24: la misma consulta construida por concatenación y pasada a [FromSqlRaw], que ejecuta el texto que se le proporciona. El valor de [name] se convierte en código SQL, la condición sigue siendo verdadera y la consulta devuelve los seis artículos (línea 24): es una inyección SQL exitosa. [FromSqlRaw] solo debe usarse con texto constante, con los valores pasados como parámetros ([FromSqlRaw("... WHERE Name = {0}", name)]);
- líneas 29–31: [Database.SqlQuery<T>] (EF Core 7 para tipos simples, EF Core 8 para los demás) ejecuta una consulta que devuelve valores de cualquier tipo, en este caso cadenas. Para un tipo simple, la columna devuelta debe llamarse [Value] (alias [AS Value]): este es el nombre que usa EF Core cuando construye la consulta con LINQ, como con el siguiente [Single] (líneas 28–32). [SqlQuery] también acepta cualquier clase, a cuyas propiedades se asignan las columnas del mismo nombre;
- líneas 40–42: [Database.ExecuteSql] ejecuta un comando de actualización, también parametrizado mediante interpolación, y devuelve el número de filas modificadas.
Todos estos métodos tienen una versión asíncrona ([ToListAsync] sobre el resultado de [FromSql], [ExecuteSqlAsync]).
11.12. Contexto e inyección de dependencias
Los ejemplos anteriores creaban sus contextos con [new]. En una aplicación por capas, y en todas las aplicaciones ASP.NET Core, los contextos los crea el contenedor de inyección de dependencias presentado en el capítulo 6. EF Core ofrece dos métodos de extensión de [IServiceCollection] para este fin:
- [AddDbContext<T>(options => ...)] registra el contexto [T] con un ciclo de vida «con ámbito» (scoped): el contenedor crea un contexto por ámbito, lo proporciona a todos los servicios de ese ámbito que lo soliciten y lo libera al final del ámbito. En una aplicación web, se crea un ámbito por cada solicitud HTTP: cada solicitud tiene su propio contexto, lo que corresponde a la unidad de trabajo del contexto;
- [AddDbContextFactory<T>(options => ...)] registra una fábrica de contextos, [IDbContextFactory<T>], cuyo método [CreateDbContext] crea un contexto nuevo en cada llamada. Se usa en servicios de larga duración (singletons), que no pueden mantener el mismo contexto durante toda la vida de la aplicación, y en el procesamiento en paralelo, que requiere un contexto por tarea.
En ambos casos, la lambda recibe un [DbContextOptionsBuilder] y configura el contexto como lo hacía [OnConfiguring]; el contexto debe tener un constructor que acepte un [DbContextOptions<T>], como el de la clase [ArticlesContext] .
El proyecto [Injection] hace referencia al paquete [Microsoft.Extensions.DependencyInjection] (versión 10.0.12, como en el capítulo 6). Define dos servicios:
- línea 7: un servicio que recibe el contexto mediante su constructor (primario). Debe registrarse con el mismo ciclo de vida que el contexto (con ámbito);
- línea 15: un servicio que recibe una fábrica de contextos;
- línea 20: cada llamada al método crea un contexto y lo libera de inmediato.
El programa es el siguiente:
Resultados:
Comentarios:
- Líneas 11–12: registro del contexto. La configuración dada aquí es la que recibe el constructor del contexto: [OnConfiguring] por lo tanto evalúa [options.IsConfigured] como verdadero y no agrega el registro de SQL. Podría agregarse aquí con [WithSqlLog];
- línea 13: el servicio [ArticlesDao], que también tiene ámbito;
- línea 17: [CreateScope()] crea un ámbito. Los servicios «con ámbito» se obtienen del proveedor de servicios del ámbito ([scope.ServiceProvider]);
- líneas 20–22: dos solicitudes del contexto dentro del mismo ámbito devuelven el mismo objeto (línea 2);
- línea 24: el contenedor crea el servicio [ArticlesDao] pasándole el contexto del ámbito;
- líneas 27–31: otro ámbito recibe un contexto distinto (línea 4);
- líneas 36–38: al final de su ámbito, el contenedor liberó el contexto; usarlo lanza una [ObjectDisposedException]. Este es el error clásico de un servicio de larga duración que retuvo un contexto recibido dentro de un ámbito;
- líneas 45–47: la fábrica de contextos y un servicio singleton que la utiliza. El servicio puede vivir tanto como la aplicación: no conserva un contexto; crea uno nuevo para cada cálculo.
Tenga presentes las reglas sobre el ciclo de vida de un contexto: de corta duración (una unidad de trabajo), nunca compartido entre varios hilos y siempre liberado ([using], o el contenedor).
11.13. Aplicación de ejemplo: versión 7
11.13.1. La arquitectura
La versión 6 de la aplicación de cálculo del impuesto (capítulo 10) leía los tramos del impuesto desde una base de datos MySQL mediante ADO.NET. La versión 7 hace lo mismo con EF Core. Como en la versión 6, solo cambia la capa [dao]: las capas [business] y [ui] de la versión 5 (capítulo 6) se reutilizan tal cual mediante referencias de proyecto.

La solución incluye dos proyectos nuevos en la carpeta [11-efcore/TaxV7]:
11.13.2. La capa [dao]
El proyecto [Tax.Dao.Ef] hace referencia a la capa [dao] de la versión 5, que contiene las entidades ([TaxBracket], [TaxException]) y la interfaz [ITaxDao]:
- línea 11: la referencia al proyecto [Tax.Dao] de la versión 5, mediante una ruta relativa;
- líneas 16–19: EF Core, Pomelo y el paquete necesario para la herramienta [dotnet ef].
La estructura [Entities.TaxBracket] de la versión 5 no puede ser una entidad de EF Core: es un [readonly record struct], que es inmodificable y no tiene clave primaria. No se modifica porque forma parte del contrato entre las capas, compartido por todas las versiones. Se crea una entidad de persistencia específica de la capa [dao], cuyo papel es representar una fila de la tabla:
- línea 6: la tabla [brackets], como en la versión 7 del curso de 2008;
- línea 10: la clave primaria, que también se usa para ordenar los tramos;
- líneas 12–19: las tres columnas, con tipos de datos [decimal] apropiados: el límite y el coeficiente [coeffN] son importes con dos decimales, y [coeffR] es una tasa con cuatro decimales.
Contexto:
- línea 6: el contexto se configura mediante su constructor: el programa principal elegirá la base de datos;
- líneas 15–17: los datos iniciales. Para evitar reescribir los tramos del impuesto, reutilizamos los de la clase [HardwiredTax] de la versión 5, que numeramos a partir de 1 con la sobrecarga de [Select], que proporciona el índice del elemento;
- Línea 18: [HasData] declara filas que forman parte del modelo. Las migraciones las insertan en la tabla y, si cambian, la siguiente migración contendrá los comandos [UPDATE], [INSERT] o [DELETE] necesarios. Las claves primarias deben especificarse explícitamente para que la herramienta pueda comparar los datos entre versiones.
La fábrica que usa la herramienta [dotnet ef]:
Solo la utiliza la herramienta durante el desarrollo: la cadena de conexión de la base de datos de desarrollo está escrita directamente en ella. En tiempo de ejecución, la cadena de conexión proviene del archivo de configuración de la aplicación.
La clase [EfTax] implementa la interfaz [ITaxDao]:
- línea 11: los códigos de error de esta implementación, como para [FileTax] y [JsonTax];
- línea 17: la capa [dao] recibe una fábrica de contextos. Será un singleton: lee los tramos de una vez por todas en su constructor, usando un contexto de corta duración que se libera de inmediato (línea 22);
- líneas 24–28: lectura de la tabla, sin seguimiento (los tramos no se modificarán), en orden de clave primaria. La proyección [Select] transforma cada entidad de persistencia en un [Entities.TaxBracket]: el resto de la aplicación nunca ve la entidad [TaxBracketEntity]. EF Core solicita al SGBD únicamente las tres columnas pertinentes;
- líneas 30–35: un error del SGBD (base de datos inaccesible, tabla inexistente, etc.) se manifiesta como una excepción derivada de [DbException], la clase base de las excepciones de los conectores ADO.NET (capítulo 10): [MySqlException] para MySqlConnector. Como en otras implementaciones, se encapsula en una [TaxException];
- líneas 39–41: una tabla vacía también es un error: la capa [business] requiere al menos un tramo.
11.13.3. La base de datos
La base de datos [eftaxes] se crea con la migración [Initial], generada por el comando [dotnet ef migrations add Initial] escrito en la carpeta del proyecto [Tax.Dao.Ef]. La herramienta aceptó una biblioteca de clases como proyecto de inicio porque contiene la fábrica [TaxContextFactory] y el paquete [Microsoft.EntityFrameworkCore.Design] (de lo contrario, se especifica un proyecto ejecutable mediante la opción [--startup-project]). La migración es la siguiente:
- líneas 19–31: creación de la tabla;
- líneas 35–46: inserción de los datos iniciales, una fila por tramo;
- línea 6: el código generado desactiva una advertencia del analizador de código relativa a las matrices multidimensionales ([new object[,]]).
El script de migración SQL muestra los comandos que se ejecutarán:
La tabla [__EFMigrationsHistory] se crea si no existe (líneas 4–8) y luego la migración se aplica en una transacción. Aplique la migración:
y se verifica el contenido de la tabla:
Los tramos de la escala están presentes, y el último tiene un límite igual a cero (la capa [business] no lo utiliza; esta selecciona el último tramo cuando ningún otro es adecuado).
Para configurar la base de datos en su equipo: la migración [Initial] ya está incluida con los códigos del curso en la carpeta [11-efcore/TaxV7/Tax.Dao.Ef/Migrations]. Por lo tanto, no es necesario volver a escribir el comando [dotnet ef migrations add Initial] (se usó para generar la migración, así que ese paso ya está completo). Simplemente:
- inicie MySQL (en Laragon; consulte el apéndice; usuario [root] sin contraseña);
- instale la herramienta [dotnet-ef] si todavía no lo ha hecho: [dotnet tool install --global dotnet-ef --version 9.0.0];
- vaya a la carpeta [11-efcore/TaxV7/Tax.Dao.Ef] y escriba el único comando [dotnet ef database update].
Entonces se crea la base de datos [eftaxes], con su tabla [brackets] poblada con los datos iniciales. Si el comando falla, verifique que MySQL esté en ejecución y que la cadena de conexión de la fábrica [TaxContextFactory] coincida con su servidor (puerto 3306, nombre de usuario [root], contraseña en blanco).
11.13.4. Integración de las capas
El proyecto ejecutable [Tax.Ui.Ef] consta de las siguientes capas:
- líneas 12–13: las capas [business] y [ui] de la versión 5. El proyecto [Tax.Ui] es un ejecutable: puede referenciarse como biblioteca para usar su clase [Ui.Dialog];
- Línea 15: la nueva capa [dao];
- línea 26: los archivos de configuración. No se llaman [appsettings.json]: el proyecto referenciado [Tax.Ui] ya copia sus propios archivos [appsettings*.json] a la carpeta de salida, y dos archivos con el mismo nombre entrarían en conflicto.
El archivo de configuración [tax-ef.json] contiene la cadena de conexión:
La sección [ConnectionStrings] es la ubicación habitual de las cadenas de conexión en la configuración de .NET: el método [config.GetConnectionString("Tax")] lee la clave [ConnectionStrings:Tax]. El archivo [tax-ef-error.json] hace referencia a una base de datos llamada [eftaxesmissing], que no existe.
El programa principal es el de la versión 5, en el que solo cambia la composición de la capa [dao]:
- líneas 21–22: la cadena de conexión leída de la configuración. Una expresión [throw] (C# 7) a la derecha de [??] lanza una excepción si falta;
- líneas 27–28: una fábrica de contextos [TaxContext], configurada con la cadena de conexión de la configuración;
- línea 30: la capa [dao] es un [EfTax]: el contenedor le pasará la fábrica de contextos. Una capa [dao] singleton no puede recibir directamente un contexto, que tiene ámbito (scoped); de ahí la fábrica;
- línea 32: la capa [business] de la versión 5;
- línea 46: el cuadro de diálogo de la versión 5.
11.13.5. Ejecuciones
Se conservan los valores de referencia de las versiones anteriores: 4282 euros para una pareja casada con dos hijos y un ingreso conjunto de 60 000 euros, 2959 euros para una familia con tres hijos y 11 519 euros para una persona soltera sin hijos.
Con el archivo de configuración [tax-ef-error.json], que hace referencia a una base de datos inexistente:
- línea 6: la excepción original, lanzada por el conector MySqlConnector, a través de EF Core;
- línea 4: la capa [dao] la encapsuló dentro de una [TaxException], que el programa principal mostró.
El curso de 2008 demostraba, en la versión 7, que la capa [dao] podía cambiar de SGBD (de MySQL a SQL Server Compact) simplemente modificando el archivo de configuración, gracias al conector genérico de ADO.NET. Con EF Core, cambiar de SGBD equivale a cambiar de proveedor: reemplazar el paquete Pomelo por el de otro SGBD (por ejemplo, [Microsoft.EntityFrameworkCore.SqlServer]) y la llamada a [UseMySql] por la llamada correspondiente ([UseSqlServer]), y luego regenerar las migraciones, que contienen información específica del proveedor. El código de la clase [EfTax], escrito en LINQ, permanece sin cambios.
11.14. Conclusión: ¿ADO.NET, Dapper o EF Core?
Ahora tenemos dos maneras de acceder a una base de datos: ADO.NET (capítulo 10) y EF Core (este capítulo). Existe una tercera, intermedia y muy utilizada: Dapper, una pequeña biblioteca (un «micro-ORM») que agrega métodos de extensión a la conexión ADO.NET. Estos métodos ejecutan una consulta SQL escrita a mano y convierten automáticamente las filas del resultado en objetos: [connection.Query<Article>("SELECT * FROM articles WHERE Price > @price", new { price = 200 })]. Usted escribe el SQL y Dapper se encarga de asignar las columnas a las propiedades.
Fortalezas | Debilidades | |
ADO.NET | Control total sobre el SQL; rendimiento; sin dependencias | mucho código repetitivo (parámetros, lectura de columnas); SQL en cadenas, no verificado por el compilador |
Dapper | SQL escrito a mano, pero sin el código de copia; rendimiento similar al de ADO.NET | Sin seguimiento de cambios ni generación de [INSERT]/[UPDATE]; sin migraciones |
EF Core | Consultas LINQ verificadas por el compilador; seguimiento de cambios; relaciones; migraciones; independiente del SGBD | una capa adicional que comprender; SQL generado que hay que monitorear; menos adecuado para procesamientos masivos complejos |
Se pueden proponer las siguientes pautas:
- EF Core es adecuado para la mayoría de las aplicaciones de gestión: un modelo de entidades interrelacionadas, operaciones de lectura y actualización de entidades y un esquema que evoluciona con la aplicación. Es la opción predeterminada para las aplicaciones ASP.NET Core;
- ADO.NET, o Dapper, es adecuado cuando se desea un control preciso sobre el SQL ejecutado: consultas de informes complejas, procedimientos almacenados, procesamiento de volúmenes muy grandes o una base de datos existente con un esquema poco adecuado para un modelo orientado a objetos;
- Estos enfoques pueden combinarse: una aplicación puede usar EF Core para la mayor parte y código SQL escrito a mano (con [FromSql], [SqlQuery] o Dapper) para unas pocas consultas críticas. EF Core también da acceso a la conexión ADO.NET que utiliza ([context.Database.GetDbConnection()]).
En cualquier caso, conocer el ORM no elimina la necesidad de entender SQL y el funcionamiento del SGBD: el registro de los comandos SQL ejecutados, que hemos mostrado a lo largo de este capítulo, es la herramienta principal para verificar lo que EF Core realmente hace.
Para obtener más información, la documentación de Microsoft es completa: Entity Framework Core. El proveedor Pomelo está documentado en su repositorio: Pomelo.EntityFrameworkCore.MySql.