Plantilla Nano ASP.NET SaaS
Datos de acceso de administrador (todos los inquilinos): admin@email.com / Password123!
Los datos de muestra se restablecen cada hora

Guía sobre Entity Framework en .NET | Aprovecha todo el potencial de los ORM, las expresiones lambda de LINQ y las migraciones | 5 preguntas clave para una entrevista de trabajo

Ryan Lewis
29 de noviembre de 2024

Mi primer proyecto en el mundo real fue una aplicación de escritorio para Windows. Contaba con un servidor de base de datos local (un ordenador guardado en el trastero del director financiero) y se desarrolló utilizando los mismos métodos que había aprendido en mis clases de programación de la universidad. Para el acceso a los datos, escribí sentencias SQL y, en cuanto al esquema, se gestionaba por separado, sin control de código fuente.

A pesar de ser un éxito para la empresa, su desarrollo fue muy complicado y, sin duda, ¡una pesadilla para quien heredara el código cuando me fui! Antes de empezar mi segundo proyecto en el mundo real, sabía que tenía que aprender sobre los ORM. Si acabas de empezar a familiarizarte con los ORM, estupendo, porque saber cómo utilizarlos llevará tus habilidades a otro nivel. Se trata más bien de una visión general que de una guía paso a paso, con preguntas de entrevista al final.

Existen ORM para todo tipo de marcos de desarrollo web. Sin embargo, en el mundo de .NET, Entity Framework Core es el principal. Entity Framework lleva años en el mercado, desde 2008, y su mantenimiento corre a cargo de Microsoft. Otro ORM que merece la pena mencionar para .NET es Dapper, pero Entity Framework será la opción por excelencia para muchos, ya que es muy bueno. Los ORM se encargan de la persistencia en el back-end; puedes utilizar Entity Framework sin MVC. El resto del diseño de tu aplicación no depende del ORM.

Si tuviera que resumir en una sola frase para qué sirven los ORM, diría lo siguiente: los ORM se encargan de todo el trabajo tedioso relacionado con las interacciones con una base de datos. Estas son algunas de las principales ventajas que puede aportar el uso de un ORM como Entity Framework Core:

La primera ventaja importante es que, en lugar de escribir sentencias SQL sin procesar, puedes utilizar LINQ. LINQ (Language Integrated Query) es una característica de .NET que utiliza expresiones lambda para ofrecer una sintaxis estandarizada, similar a la de SQL, que permite consultar y transformar datos de diferentes fuentes, como colecciones, bases de datos y XML.

Las mismas expresiones lambda que escribes para manipular listas, enumerables y colecciones se utilizan para recuperar datos de una base de datos. Algunas de las ventajas son que no es necesario parametrizar cadenas y que se beneficia de IntelliSense y de la seguridad de tipos. En general, LINQ es mucho más fácil de escribir que el SQL puro. En segundo plano, Entity Framework traduce las sentencias LINQ a SQL puro, por muy complejas que sean, con subconsultas, uniones, joins, etc. A modo de ejemplo, aquí tienes un ejemplo sencillo de cómo podrías utilizar una expresión lambda de LINQ para seleccionar el valor máximo con Entity Framework Core

// Suponiendo que 'context' es tu DbContext y 'Products' es tu DbSet
var valorMáximo = contexto.Productos
    .Max(e => e.Nombre de la columna);

Y aquí tenemos una instrucción `lambda select` que el ORM traduciría a SQL sin procesar

SELECT MAX(Nombre de la columna) DE Productos

Veamos ahora un ejemplo más complejo (extraído de uno de mis proyectos) de una instrucción LINQ:

var consulta = _contexto.Políticas
    .Incluir(x => x.Estaciones)
    .Incluir(x => x.Itinerario y productos).ThenInclude(x => x.Producto)
    .Incluir(x => x.Itinerario y productos).ThenInclude(x => x.Producto.Habitaciones);

Como SQL sin procesar, ¡vaya!

SELECT 
    p.*,    -- Seleccionar todos columnas de el Políticas tabla
    s.*,    -- Seleccionar todos columnas de el Estaciones tabla
    ip.*,   -- Seleccionar todos columnas de el Itinerario y productos tabla
    pr.*,   -- Seleccionar todos columnas de el Productos tabla
    r.*     -- Seleccionar todos columnas de el Habitaciones tabla
DE Políticas p
IZQUIERDA ÚNETE Estaciones s EN p.Id = s.Id. de la póliza
IZQUIERDA ÚNETE Itinerario y productos ip EN p.Id = ip.Id. de la póliza
IZQUIERDA ÚNETE Productos pr EN ip.ID del producto = pr.Id
IZQUIERDA ÚNETE Habitaciones r EN pr.Id = r.ID del producto
ORDEN POR p.Fecha de inicio;

La siguiente ventaja es que, al utilizar migraciones y el diseño «code-first», el esquema de tu base de datos pasará a estar bajo control de versiones.

Al principio, el desarrollo «code-first» no me parecía que tuviera mucho sentido. Siempre había creado la base de datos por separado: creaba las tablas, diseñaba el esquema, etc., en una herramienta de bases de datos como MySQL Workbench o SSMS. La aplicación no tenía ningún conocimiento de la base de datos, salvo una cadena de conexión. Si cambiaba el nombre de una tabla en la base de datos, cualquier instrucción SQL que hiciera referencia a ella en el código simplemente dejaba de funcionar. Tampoco había forma de realizar un seguimiento de los cambios en el esquema. Contaba con control de código fuente para el código, pero no para la base de datos.

Las migraciones «code-first» resolvieron todos estos problemas. Lo fundamental es comprender que se utilizará código para diseñar la base de datos, y no una herramienta de bases de datos independiente.

Entity Framework utiliza una clase denominada «contexto de base de datos» (DbContext). Dentro de esta clase de contexto hay referencias a todas las entidades que se van a gestionar como tablas en la base de datos (DbSets). Estas clases de entidad son simples clases C# con propiedades que definen las columnas.

Por ejemplo, crear una clase llamada «Productos» y añadirla como una DbSet a la DbContext Esto dará lugar a la creación de una tabla de productos en la base de datos. Para crear columnas, hay que definirlas como propiedades en la clase. Entity Framework traducirá el Tipos C# a tipos de bases de datos para ti. A cadena La propiedad generará un nvarchar columna en SQL Server, por ejemplo. EF también te ofrece anotaciones de datos para un control aún mayor sobre los atributos de las columnas.

público clase Producto
{
    público int Id { obtener; set; }
    público cadena Nombre { obtener; set; }
    público cadena Descripción { obtener; set; }

    // Clave externa para la relación
    público int Id. del proveedor { obtener; set; }
    
    // Propiedad de navegación para volver a «Proveedor»
    público Proveedor Proveedor { obtener; set; }
}

Las relaciones entre tipos de entidad se definen siguiendo una convención. Existen convenciones para todo tipo de relaciones: uno a muchos, uno a uno y muchos a muchos. A continuación se muestra cómo podría verse una relación típica de uno a muchos en Entity Framework:

público clase Proveedor
{
    público int Id { obtener; set; }
    público cadena Nombre { obtener; set; }
    público cadena Dirección { obtener; set; }
    público cadena Teléfono { obtener; set; }

    // Propiedad de navegación de una colección para una relación uno a muchos
    público Lista<Producto> Productos { obtener; set; }
}

Cualquier propiedad cuyo nombre coincida con el de una tabla existente y a la que se le añada un identificador se configurará como clave externa por convención. Añadir propiedades de navegación de tipo ICollection es opcional, pero incluirlas permitirá a Entity Framework recuperar datos relacionados cada vez que crees tus consultas LINQ. Los datos de las tablas relacionadas pueden cargarse de forma diferida o anticipada para optimizar el rendimiento.

Aunque la configuración basada en convenciones de Entity Framework es muy fácil de usar, a veces es posible que quieras tener un poco más de control. Por este motivo, EF te permite configurar todo de forma explícita si lo necesitas. Dentro de las clases de entidad o de la clase de contexto de la base de datos, puedes establecer configuraciones explícitas mediante expresiones fluidas.

Dado que el mapa completo de la base de datos se define como código en tus clases de entidad, EF puede manipular los datos de una base de datos con la misma facilidad que si estuvieras transformando datos dentro de un objeto `List` o `Enumerable`.

Una vez definidas todas las clases de entidad y referenciadas en la clase de contexto de la base de datos, podemos crear nuestra primera migración para aplicar realmente los cambios a la base de datos. En este momento, si ejecutáramos la aplicación, no existiría ninguna base de datos ni nuestra aplicación crearía ninguna. De hecho, también aparecerían varios errores, ya que EF es capaz de detectar si hay alguna diferencia entre la base de datos y los modelos.

Una migración es como una instantánea del estado evolutivo de tu esquema. Una migración es una clase generada automáticamente por las herramientas de tiempo de diseño de Entity Framework. Desde la línea de comandos, podemos utilizar el comando añadir migración para ello. Si no defines un directorio de salida específico, EF creará una carpeta llamada Migraciones en tu proyecto y mantén las clases allí. Estas migraciones quedarán pendientes hasta que se apliquen realmente mediante el actualizar-base-de-datos comando.

El código generado en las clases de migración contiene scripts SQL. Cuando se aplica con actualizar-base-de-datos, estos comandos generan un esquema que se ajusta al diseño de tus clases de entidad en la base de datos de destino. Si la base de datos no existe, EF creará una nueva utilizando el nombre que hayas definido en la cadena de conexión predeterminada. Estas clases de migración contienen dos secciones de código: arriba y hacia abajo. Los comandos del arriba El método se ejecutará cada vez que apliques una migración; los comandos del hacia abajo Este método se ejecutará si deseas volver a un estado anterior de la migración. A continuación te mostramos cómo podría ser nuestra migración de las tablas «Product» y «Supplier» (suponiendo que hayas realizado una única migración para ambas tablas):

público parcial clase Creación inicial : Inmigración
{
    protegido anular nulo Arriba(MigrationBuilder migrationBuilder)
    {
        migrationBuilder.CreateTable(
            nombre: "Proveedores",
            columnas: tabla => nuevo
            {
                Id = tabla.Columna<int>(tipo: "int", que puede ser nulo: false)
                    .Nota("SqlServer:Identity", "1, 1"),
                Nombre = tabla.Columna<cadena>(tipo: "nvarchar(max)", que puede ser nulo: verdadero),
                Dirección = tabla.Columna<cadena>(tipo: "nvarchar(max)", que puede ser nulo: verdadero),
                Teléfono = tabla.Columna<cadena>(tipo: "nvarchar(max)", que puede ser nulo: verdadero)
            },
            restricciones: tabla =>
            {
                tabla.Clave primaria("PK_Proveedores", x => x.Id);
            });

        migrationBuilder.CreateTable(
            nombre: "Productos",
            columnas: tabla => nuevo
            {
                Id = tabla.Columna<int>(tipo: "int", que puede ser nulo: false)
                    .Nota("SqlServer:Identity", "1, 1"),
                Nombre = tabla.Columna<cadena>(tipo: "nvarchar(max)", que puede ser nulo: verdadero),
                Descripción = tabla.Columna<cadena>(tipo: "nvarchar(max)", que puede ser nulo: verdadero),
                Id. del proveedor = tabla.Columna<int>(tipo: "int", que puede ser nulo: false)
            },
            restricciones: tabla =>
            {
                tabla.Clave primaria("PK_Productos", x => x.Id);
                tabla.Clave externa(
                    nombre: "FK_Productos_Proveedores_IdProveedor",
                    columna: x => x.Id. del proveedor,
                    tabla principal: "Proveedores",
                    columna principal: "Id",
                    onDelete: Acción referencial.Cascada);
            });

        migrationBuilder.Crear índice(
            nombre: "IX_Productos_IdProveedor",
            tabla: "Productos",
            columna: "Id. del proveedor");
    }

    protegido anular nulo Abajo(MigrationBuilder migrationBuilder)
    {
        migrationBuilder.DropTable(
            nombre: "Productos");

        migrationBuilder.DropTable(
            nombre: "Proveedores");
    }
}

Entity Framework realiza un seguimiento de los cambios mediante una tabla de la base de datos y una clase de instantánea del modelo de contexto de la base de datos, ubicada en la carpeta «migrations». Cada nueva migración solo generará código para aplicar los cambios entre una migración y la siguiente. Por ejemplo, supongamos que has creado una migración inicial para una aplicación que tenía una entidad «Product». Posteriormente, añades otra entidad para «Supplier». En el momento en que crees una nueva migración para «Supplier», esta solo contendrá código relacionado con la entidad «Supplier» y cualquier nueva relación. Cuando ejecutemos el actualizar-base-de-datos Con este comando, todas las migraciones pendientes se aplicarán en orden cronológico.

Dado que estas clases de migración se almacenan junto con la aplicación en el control de versiones, cualquiera que descargue tu repositorio más adelante podrá recrear la base de datos exactamente tal y como debería estar en este momento. Esto supone un gran cambio para cualquiera que necesite trabajar en equipo o que, simplemente, desee mantener un mínimo de cordura.

Las migraciones también son de vital importancia en las aplicaciones multitenant. Cuando se crean nuevos tenants sobre la marcha con una base de datos independiente, son estas migraciones las que lo hacen posible. La multitenencia es un tema un poco más avanzado, pero resulta esencial si quieres desarrollar aplicaciones SaaS para el gran público. Si ese es tu objetivo, Nano ASP.NET Boilerplate es una plantilla de proyecto adaptable que se puede utilizar para generar todo tipo de proyectos nuevos, incluidas aplicaciones SaaS multitenant.  

Este artículo solo ha abordado los aspectos básicos de lo que pueden hacer herramientas como Entity Framework. Es fundamental conocer las migraciones «code-first» y LINQ, pero hay mucho más. Puedes ejecutar código cada vez que se guardan los cambios, puedes implementar filtros de consulta globales e incluso aplicar configuraciones diferentes para cada solicitud.

La persistencia de datos es un tema muy amplio y los ORM son solo una parte de él. Cuando se utilizan junto con patrones como el repositorio genérico y la especificación (especialmente la especificación de Ardalis), empezarás a descubrir todo el potencial de ASP.NET y a crear aplicaciones verdaderamente escalables. La plantilla Nano es una plantilla de proyecto que hemos desarrollado y que combina únicamente lo mejor de estos patrones y prácticas. Úsala en un número ilimitado de proyectos y genera soluciones bien diseñadas al instante. Se mantiene siempre actualizada e incluye tres proyectos de interfaz de usuario.

Espero que este artículo haya servido de guía útil para adentrarse en el mundo de los ORM y, en particular, de Entity Framework Core. ¡Hay muchísima documentación técnica y tutoriales sobre Entity Framework disponibles de forma gratuita, tanto en la página web de Microsoft como en otras fuentes de Internet!

1. ¿Qué es Entity Framework y cuáles son sus principales ventajas?

Objetivo: Evaluar la comprensión que tiene el candidato del objetivo principal y las ventajas de EF.
Respuesta esperada: Entity Framework es un mapeador objeto-relacional (ORM) para .NET que simplifica las operaciones con bases de datos al permitir a los desarrolladores trabajar con entidades de la base de datos mediante objetos C#. Entre sus ventajas se incluyen:

  • Menor necesidad de escribir código SQL sin procesar.
  • Consultas de tipado estricto para garantizar la seguridad en tiempo de compilación.
  • Compatibilidad integrada con LINQ para consultar datos.
  • Enfoques de desarrollo «Database-First», «Code-First» y «Model-First».

2. Explica las diferencias entre los enfoques «Code-First», «Database-First» y «Model-First» en EF.

Objetivo: Evaluar los conocimientos sobre los distintos flujos de trabajo de EF y sus casos de uso.
Respuesta esperada:

  • «Code-First»: Define la estructura de la base de datos utilizando las clases de C#. EF genera el esquema de la base de datos a partir del modelo. Ideal para proyectos que se empiezan desde cero.
  • «La base de datos primero»: Si se parte de una base de datos ya existente, EF genera el modelo y el contexto a partir del esquema. Es adecuado para bases de datos heredadas.
  • «Model-First»: Define la base de datos de forma visual en un diseñador y EF generará el esquema y las clases. Resulta útil para proyectos que requieren un enfoque visual.

3. ¿Cuál es la diferencia entre DbSet y DbContext ¿En Entity Framework?

Objetivo: Para evaluar el conocimiento que tiene el candidato de los componentes fundamentales de la EF.
Respuesta esperada:

  • DbContext: La clase principal encargada de interactuar con la base de datos. Gestiona la conexión, realiza un seguimiento de los cambios y se encarga de las operaciones CRUD.
  • DbSet: Representa un conjunto de entidades de un tipo específico que EF gestiona e interactúa con ellas en la base de datos. Se utiliza para consultar y guardar instancias de entidades.

4. ¿Qué son la carga anticipada, la carga diferida y la carga explícita en EF, y cuándo se utilizaría cada una de ellas?

Objetivo: Evaluar el conocimiento sobre las estrategias de carga de datos y la optimización del rendimiento.
Respuesta esperada:

  • Carga anticipada: Carga las entidades relacionadas con la entidad principal en una sola consulta. Úsala cuando sepas que vas a necesitar datos relacionados.
  • Carga diferida: Solo carga las entidades relacionadas cuando se accede a ellas. Es una buena opción para reducir al mínimo el tiempo de carga inicial, pero puede dar lugar a múltiples consultas (problema N+1).
  • Carga explícita: Carga manualmente los datos relacionados mediante .Load(). Resulta útil para controlar con precisión la obtención de datos.

5. ¿Cómo gestiona EF la concurrencia y cómo se pueden resolver los conflictos de concurrencia?

Objetivo: Evaluar los conocimientos sobre la gestión de la concurrencia en EF.
Respuesta esperada: EF gestiona la concurrencia mediante un ConcurrencyToken. Cuando dos usuarios intentan actualizar los mismos datos al mismo tiempo, se produce un DbUpdateConcurrencyException se lanza.

  • Para resolver conflictos, utiliza Control optimista de la concurrencia con propiedades como la columna «RowVersion».
  • Las opciones para resolver conflictos incluyen la priorización del cliente, la priorización de la tienda o una lógica de fusión personalizada.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

¿Necesitas una plantilla de ASP.NET para desarrollar tu próximo MVP?
Echa un vistazo al proyecto de plantilla Nano ASP.NET para SaaS multitenant y ahorra semanas o meses de tiempo de desarrollo.
Más información