¿Se trabaja LINQ de forma profunda o solo lo justo para EF?

Se trabaja de forma profunda. El curso cubre LINQ como lenguaje de consulta en C#, incluyendo lambdas, operadores estándar, `IEnumerable`, `IQueryable` e `IAsyncEnumerable`. Además, en .NET 10 se añaden oficialmente `LeftJoin` y `RightJoin` en `Enumerable` y `Queryable`, y la propia plataforma incluye `AsyncEnumerable` para LINQ sobre secuencias asíncronas.

¿Se ven novedades específicas de EF Core 10?

Sí. Entre otras cosas, el curso incorpora soporte de EF Core 10 para los operadores LeftJoin y RightJoin de .NET 10, además de named query filters y mejoras en traducción LINQ/SQL. Todo ello se trabaja no como curiosidad, sino como parte de patrones útiles de proyecto real.

¿Incluye rendimiento y optimización o es un curso solo de CRUD y modelado?

Incluye rendimiento con bastante profundidad. La documentación oficial de EF Core dedica secciones específicas a efficient querying, advanced performance topics, compiled models y compiled queries. El curso lo traduce a decisiones prácticas sobre proyecciones, includes, tracking, split queries, shape de datos y optimización del arranque.

¿Se cubren migraciones y despliegue en entornos reales?

Sí. Se trabaja creación, revisión y aplicación de migraciones, generación de scripts SQL y criterios de despliegue. Microsoft recomienda especialmente el uso de scripts porque pueden revisarse, ajustarse y formar parte del proceso de CI o despliegue, algo muy importante cuando se opera en producción con datos reales.

¿Se aborda la creación del DbContext para tooling y CLI?

Sí. La documentación oficial de EF Core explica expresamente la design-time DbContext creation porque herramientas como las migraciones necesitan poder crear una instancia derivada del contexto fuera del flujo normal de ejecución. El curso cubre este punto con detalle, incluyendo `IDesignTimeDbContextFactory `.

¿Se trabajan operaciones masivas como actualizaciones o borrados sin cargar entidades?

Sí. EF Core incluye `ExecuteUpdate` y `ExecuteDelete`, que permiten actualizar o borrar directamente en base de datos sin usar el tracking tradicional ni `SaveChanges()`. El curso dedica un bloque completo a cuándo conviene usar estas operaciones y cuándo no.

¿Hace falta SQL Server o vale cualquier proveedor?

El curso puede trabajarse con SQL Server, PostgreSQL o SQLite, pero se recomienda tener al menos un proveedor relacional real para ver bien migraciones, SQL generado, concurrencia y rendimiento. EF Core mantiene un modelo de proveedores y funciona con SQL Server, Azure SQL, SQLite, Cosmos DB, MySQL, PostgreSQL y otros motores compatibles.

¿Puede bonificarse por FUNDAE?

Sí. En contexto corporativo, esta formación puede plantearse como bonificable hasta el 100% si la empresa dispone de crédito suficiente y tramita correctamente la acción formativa conforme al marco aplicable.

Curso de Entity Framework y LinQ para Equipos de Desarrollo

Aprende con el curso de Entity Framework y LinQ para empresas hasta 100% bonificado, a medida para tu organización.

Totalmente práctico y aplicable

Formación en Entity Framework y LinQ a medida

100% bonificable a través de FUNDAE

Curso TUTORIZADO por expertos

Solicitar precio

Me interesa

Calcula mis créditos de FUNDAE

Solicitar precio

Calcula mis créditos de FUNDAE

Programa formativo

Temario del curso

Encuentra todo el temario del curso aquí.

Temario

Comprensión de qué papel juega EF Core 10 dentro de una arquitectura .NET moderna y de por qué no debe verse como una simple capa automática de CRUD.
Revisión de la relación entre C# 14, LINQ, proveedores de base de datos, `DbContext` y motor de traducción de consultas.
Análisis de cómo conviven expresividad, rendimiento y mantenibilidad cuando se usa LINQ sobre `IQueryable`.
Diferenciación entre acceso a datos imperativo, acceso relacional clásico y acceso a datos orientado a dominio con EF Core.
Identificación de las responsabilidades que debe asumir EF Core y de las que deben quedarse en servicios, dominio o capa de aplicación.
Revisión del valor real de un ORM cuando el proyecto crece y aparecen varios equipos, varios módulos y varias necesidades de reporting.
Trabajo sobre el coste de las malas decisiones tempranas de modelado y de consulta en proyectos .NET de larga vida.
Comprensión del binomio EF Core + LINQ como una capacidad estratégica del stack .NET y no como una herramienta secundaria.
Detección de anti-patrones frecuentes: contextos gigantes, repositorios vacíos de sentido, consultas en memoria involuntarias y exceso de abstracción.
Taller de diagnóstico inicial sobre cómo se está usando EF Core hoy en un proyecto real.

Comprensión de qué papel juega EF Core 10 dentro de una arquitectura .NET moderna y de por qué no debe verse como una simple capa automática de CRUD.
Revisión de la relación entre C# 14, LINQ, proveedores de base de datos, `DbContext` y motor de traducción de consultas.
Análisis de cómo conviven expresividad, rendimiento y mantenibilidad cuando se usa LINQ sobre `IQueryable`.
Diferenciación entre acceso a datos imperativo, acceso relacional clásico y acceso a datos orientado a dominio con EF Core.
Identificación de las responsabilidades que debe asumir EF Core y de las que deben quedarse en servicios, dominio o capa de aplicación.
Revisión del valor real de un ORM cuando el proyecto crece y aparecen varios equipos, varios módulos y varias necesidades de reporting.
Trabajo sobre el coste de las malas decisiones tempranas de modelado y de consulta en proyectos .NET de larga vida.
Comprensión del binomio EF Core + LINQ como una capacidad estratégica del stack .NET y no como una herramienta secundaria.
Detección de anti-patrones frecuentes: contextos gigantes, repositorios vacíos de sentido, consultas en memoria involuntarias y exceso de abstracción.
Taller de diagnóstico inicial sobre cómo se está usando EF Core hoy en un proyecto real.

¿Tienes dudas?

Estamos aquí para ayudarte

Reservar plaza

Tema 1: Visión completa de EF Core 10, LINQ y el acceso a datos moderno en .NET 10

Comprensión de qué papel juega EF Core 10 dentro de una arquitectura .NET moderna y de por qué no debe verse como una simple capa automática de CRUD.
Revisión de la relación entre C# 14, LINQ, proveedores de base de datos, `DbContext` y motor de traducción de consultas.
Análisis de cómo conviven expresividad, rendimiento y mantenibilidad cuando se usa LINQ sobre `IQueryable`.
Diferenciación entre acceso a datos imperativo, acceso relacional clásico y acceso a datos orientado a dominio con EF Core.
Identificación de las responsabilidades que debe asumir EF Core y de las que deben quedarse en servicios, dominio o capa de aplicación.
Revisión del valor real de un ORM cuando el proyecto crece y aparecen varios equipos, varios módulos y varias necesidades de reporting.
Trabajo sobre el coste de las malas decisiones tempranas de modelado y de consulta en proyectos .NET de larga vida.
Comprensión del binomio EF Core + LINQ como una capacidad estratégica del stack .NET y no como una herramienta secundaria.
Detección de anti-patrones frecuentes: contextos gigantes, repositorios vacíos de sentido, consultas en memoria involuntarias y exceso de abstracción.
Taller de diagnóstico inicial sobre cómo se está usando EF Core hoy en un proyecto real.

Tema 2: Arquitectura de proyectos .NET 10 orientados a datos y persistencia limpia

Diseño de una solución .NET 10 con separación razonable entre dominio, aplicación, infraestructura y capa de presentación.
Revisión de dónde debe vivir `DbContext`, dónde deben vivir las entidades y cómo evitar el acoplamiento innecesario entre capas.
Construcción de una estructura de proyectos que facilite tests, migraciones, despliegue y mantenimiento del modelo relacional.
Trabajo sobre el equilibrio entre Clean Architecture y pragmatismo cuando EF Core es parte central del backend.
Revisión de patrones de composición para APIs, servicios de aplicación y jobs que comparten persistencia.
Preparación de una organización de código que haga visibles las decisiones de acceso a datos y no las diluya entre helpers dispersos.
Análisis del valor de separar el proyecto de migraciones cuando el contexto lo requiere y de cuándo no compensa hacerlo.
Detección de problemas de diseño cuando la infraestructura acaba contaminando el dominio o la capa web.
Construcción de una convención técnica para nombres, carpetas, configuraciones y bootstrapping de persistencia.
Taller de diseño de solución base para un backend corporativo con EF Core.

Tema 3: DbContext, DbSet y lifetime correcto de la unidad de trabajo

Comprensión profunda de `DbContext` como unidad de trabajo corta y desechable, y no como singleton ni como almacén de estado duradero.
Revisión de la vida útil del contexto y de cómo afecta a tracking, memoria, concurrencia y consistencia de cambios.
Trabajo sobre el papel de `DbSet` como punto de entrada al modelo y no como simple “tabla” disfrazada.
Diseño de registro y configuración de contextos con inyección de dependencias en ASP.NET Core.
Análisis de patrones correctos e incorrectos de uso del contexto en web, workers, servicios de fondo y procesos batch.
Preparación de contextos especializados por bounded context, módulo o área funcional cuando el sistema lo exige.
Revisión de cómo evitar contextos compartidos en exceso entre operaciones distintas o capas demasiado alejadas.
Detección de fugas de contexto, problemas de thread-safety y errores al mantener entidades vivas más allá de la unidad de trabajo.
Construcción de hábitos correctos para crear, usar y desechar `DbContext` con seguridad técnica.
Taller de diseño de lifetime, registro y resolución de `DbContext`.

Tema 4: Modelado de entidades y traducción del dominio al modelo relacional

Trabajo sobre cómo convertir entidades de negocio en tipos persistibles sin degradar demasiado la expresividad del dominio.
Revisión de decisiones sobre identidad, mutabilidad, encapsulación y exposición de propiedades dentro del modelo de EF Core.
Diseño de clases de entidad preparadas para tracking, consultas y mantenimiento a largo plazo.
Análisis de cuándo usar propiedades privadas, setters controlados y métodos de dominio sin sabotear el funcionamiento del ORM.
Preparación de una estrategia coherente para entidades ricas, entidades anémicas y modelos híbridos.
Detección de anti-patrones al modelar para la base de datos en vez de para el negocio o viceversa.
Revisión de cómo el modelo conceptual y el modelo relacional se alinean o tensionan según el caso.
Construcción de una disciplina de naming y coherencia entre código, tablas, claves y relaciones.
Trabajo sobre límites del agregado y sobre cómo impactan en el diseño de entidades y navigations.
Taller de modelado inicial de varias entidades de negocio.

Tema 5: Configuración del modelo: convenciones, Data Annotations y Fluent API

Comprensión de qué resuelve EF Core por convención y de qué conviene configurar explícitamente para evitar ambigüedad.
Revisión de cuándo usar Data Annotations y cuándo pasar a Fluent API para mantener el modelo más limpio y expresivo.
Diseño de configuraciones desacopladas mediante `IEntityTypeConfiguration<T>` para evitar sobrecargar las entidades.
Trabajo sobre configuración centralizada del modelo y legibilidad a medio plazo del mapping.
Revisión de cómo mapear nombres de tablas, columnas, índices, restricciones y comportamientos de relación.
Preparación de una estrategia de configuración uniforme para equipos con varios desarrolladores.
Detección de problemas cuando una parte del mapping vive dispersa entre anotaciones, `OnModelCreating` y configuraciones externas.
Construcción de convenciones internas que hagan el proyecto más mantenible y menos dependiente de memoria tribal.
Trabajo sobre override consciente de convenciones en vez de configuración excesiva por costumbre.
Taller de organización y refactor del mapping de un modelo mediano.

Tema 6: Claves, índices, valores generados y decisiones de identidad

Revisión de claves primarias simples, compuestas y alternativas, y de su impacto sobre tracking, relaciones y queries.
Diseño de índices alineados con los patrones reales de acceso a datos y no solo con el diseño inicial del modelo.
Trabajo sobre columnas autogeneradas, valores por defecto, columnas calculadas y estrategias de generación de valores.
Análisis del coste de malas decisiones de identidad en rendimiento, migraciones y evolución del modelo.
Preparación de reglas coherentes para GUID, enteros incrementales, claves naturales y claves de integración.
Revisión de cómo se configuran valores generados en bases relacionales y cómo afecta eso al ciclo de persistencia.
Detección de problemas derivados de índices ausentes en filtros frecuentes, ordenaciones o joins habituales.
Construcción de una metodología para revisar el modelo físico y no quedarse solo en el objeto C#.
Trabajo sobre naming, unicidad y restricciones que refuercen la integridad del dato.
Taller de diseño de claves, índices y valores generados.

Tema 7: Relaciones: uno a muchos, uno a uno, muchos a muchos y navigations

Comprensión profunda de cómo EF Core define relaciones a partir de claves externas y navigations.
Revisión de escenarios uno a muchos, uno a uno y muchos a muchos con sus implicaciones prácticas de diseño.
Trabajo sobre navigations como vista orientada a objetos por encima de claves foráneas y no como simple azúcar sintáctico.
Diseño de relaciones que reflejen bien el dominio sin generar dependencias cíclicas o grafos difíciles de cargar.
Análisis de configuraciones bidireccionales, unidireccionales y sin navigation según necesidad real.
Preparación de relaciones muchos a muchos con entidad explícita cuando el negocio pide payload adicional.
Detección de errores comunes al modelar cardinalidades por intuición y no por reglas reales del negocio.
Revisión de consistencia entre nullabilidad, required/optional y semántica de la relación.
Construcción de hábitos seguros para modificar grafos relacionados sin romper integridad.
Taller de modelado y configuración de relaciones complejas.

Tema 8: Value objects, owned entities y modelado rico del dominio

Trabajo sobre cuándo una estructura del dominio debe mapearse como entidad y cuándo como value object o componente dependiente.
Revisión del uso de owned entity types para modelar partes del agregado que no tienen identidad propia.
Diseño de objetos de valor reutilizables para direcciones, importes, coordenadas, configuraciones o datos compuestos.
Análisis de cómo owned types ayudan a mantener el lenguaje de dominio sin multiplicar tablas innecesarias.
Preparación de decisiones de modelado donde la composición sea más natural que la identidad explícita.
Revisión de los límites de las owned entities y de cómo afectan a queries, actualizaciones y evolución del modelo.
Detección de errores frecuentes al intentar forzar value objects en escenarios que realmente exigen entidad propia.
Construcción de una metodología para mapear objetos ricos sin empobrecer el dominio ni complicar en exceso el schema.
Trabajo sobre comparación conceptual entre value objects, owned types y complex structures dentro del modelo.
Taller de modelado avanzado con value objects y owned entities.

Tema 9: Configuración de proveedores, cadenas de conexión y creación en tiempo de diseño

Revisión de cómo configurar EF Core con SQL Server, PostgreSQL, SQLite u otros proveedores según contexto del proyecto.
Diseño de una estrategia de connection strings y secretos adecuada para desarrollo, pruebas, staging y producción.
Trabajo sobre creación del `DbContext` en tiempo de diseño para herramientas de migración y scaffolding.
Preparación de `IDesignTimeDbContextFactory` cuando la solución o el arranque del host lo hacen necesario.
Revisión de diferencias entre configuración en `Program.cs`, factorías y contextos específicos para tooling.
Detección de errores habituales cuando `dotnet ef` no puede crear el contexto o lo crea con configuración incorrecta.
Construcción de un modelo operativo para CLI, CI/CD y trabajo local sin fricción innecesaria.
Trabajo sobre provider-specific behavior y sobre cómo evitar supuestos peligrosos de portabilidad total.
Revisión de buenas prácticas para aislar configuración sensible del código de infraestructura.
Taller de configuración completa de proveedores y design-time creation.

Tema 10: Migraciones de esquema con criterio profesional

Comprensión del valor de las migraciones como historia versionada del modelo relacional y no como simple mecanismo automático.
Revisión de creación, revisión, refactor y limpieza de migraciones durante el ciclo de desarrollo.
Diseño de una estrategia para cambios de esquema seguros en equipos y entornos compartidos.
Trabajo sobre migraciones manuales, refactorizaciones del modelo y cuidado con operaciones potencialmente destructivas.
Preparación de scripts SQL revisables para producción cuando se requiere más control que una ejecución automática.
Revisión de ventajas de scriptar cambios para DBA, auditoría y despliegues más seguros.
Detección de errores de equipo como reescribir migraciones ya compartidas o aplicar cambios de modelo sin disciplina.
Construcción de un flujo de trabajo claro para crear, revisar, probar y desplegar migraciones.
Trabajo sobre separación entre migraciones de desarrollo y criterio de aplicación en producción.
Taller de ciclo completo de migraciones desde cambio de modelo hasta script final.

Tema 11: Seeding inicial y datos gestionados con criterio

Revisión de las distintas estrategias actuales para poblar bases con datos iniciales en EF Core.
Comprensión del papel de `UseSeeding`, `UseAsyncSeeding`, `HasData`, inicialización personalizada y personalización manual de migraciones.
Diseño de una estrategia de seeding adecuada según si el dato es técnico, funcional, demo o de bootstrap operativo.
Trabajo sobre qué información conviene sembrar por configuración y cuál debe gestionarse fuera del modelo.
Análisis de riesgos al mezclar datos operativos vivos con datos gestionados por migración.
Preparación de seeds reproducibles para desarrollo, demo, QA y arranque controlado de nuevos entornos.
Detección de problemas cuando el seeding se dispersa entre scripts, código manual y migraciones sin criterio único.
Construcción de un modelo de inicialización que no dañe consistencia ni trazabilidad.
Trabajo sobre locking de migraciones y seeding en tiempo de despliegue.
Taller de implementación de varias estrategias de seeding en un proyecto real.

Tema 12: LINQ en C#: fundamentos sólidos para consultar con precisión

Comprensión de LINQ como tecnología integrada en C# para expresar consultas de forma tipada y composable.
Revisión de query syntax, method syntax, lambdas y funciones anónimas como base expresiva del lenguaje.
Trabajo sobre la diferencia conceptual entre operaciones sobre secuencias en memoria y construcción de árboles de expresión.
Diseño de consultas claras, legibles y refactorizables sin caer en cadenas opacas de operadores.
Análisis del papel de `Where`, `Select`, `OrderBy`, `GroupBy`, `Any`, `All`, `Contains`, `First`, `Single` y otros operadores estándar.
Preparación de una base sintáctica fuerte para no usar LINQ por ensayo y error.
Detección de anti-patrones como consultas innecesariamente rebuscadas, abusos de materialización o encadenados poco legibles.
Revisión de cómo las lambdas de C# 14 siguen siendo núcleo expresivo del trabajo con LINQ.
Construcción de una intuición clara sobre pipelines de transformación, filtrado y proyección.
Taller de refactor de consultas desde código imperativo a LINQ expresivo.

Tema 13: IEnumerable, IQueryable e IAsyncEnumerable: tres naturalezas distintas de LINQ

Comprensión profunda de por qué LINQ cambia de comportamiento según la abstracción sobre la que se aplique.
Revisión de `IEnumerable<T>` como pipeline en memoria, `IQueryable<T>` como consulta traducible y `IAsyncEnumerable<T>` como secuencia asíncrona.
Trabajo sobre cómo un mismo operador puede significar cosas muy distintas en función del proveedor subyacente.
Análisis de deferred execution, materialización y momento real de ejecución de la consulta.
Preparación de criterios para decidir cuándo conviene seguir en `IQueryable` y cuándo cortar hacia memoria.
Detección de errores frecuentes al mezclar operaciones traducibles con lógica que solo puede vivir en memoria.
Revisión del papel de `AsyncEnumerable` en .NET 10 como soporte de LINQ para `IAsyncEnumerable<T>`.
Construcción de una intuición práctica para leer el coste de cada decisión en una consulta compleja.
Trabajo sobre la relación entre abstracción, legibilidad y rendimiento real.
Taller de comparación entre consultas sobre `IEnumerable`, `IQueryable` e `IAsyncEnumerable`.

Tema 14: Filtros, proyecciones, ordenación, paginación y composición de queries

Diseño de consultas LINQ mantenibles para listados, búsquedas, filtros compuestos y pantallas de consulta reales.
Trabajo sobre proyección temprana para reducir carga de datos y evitar materializar entidades completas sin necesidad.
Revisión de composición progresiva de queries para escenarios de búsqueda dinámica sin construir SQL a mano.
Preparación de pipelines con filtros opcionales, ordenaciones condicionales y paginación estable.
Análisis de cómo cambia el rendimiento cuando se filtra tarde, se proyecta mal o se ordena sobre campos poco adecuados.
Detección de errores de diseño en listados corporativos de gran volumen.
Construcción de DTO projections más eficientes y expresivas para API y backoffice.
Trabajo sobre separación entre query object, application service y controlador para mantener la lógica legible.
Revisión de patrones de consulta reutilizable sin caer en abstracciones artificiales.
Taller de construcción de un módulo completo de búsqueda y listados.

Tema 15: Joins, groupings y operadores avanzados de LINQ en .NET 10

Comprensión de joins internos, group joins y outer joins dentro del ecosistema LINQ y su papel en consultas reales.
Revisión de los nuevos operadores LeftJoin y RightJoin disponibles en .NET 10 sobre `Enumerable` y `Queryable`.
Trabajo sobre cómo EF Core 10 traduce estos operadores a SQL y simplifica consultas que antes resultaban más verbosas.
Diseño de consultas con joins legibles, correctos y alineados con la intención funcional del caso de uso.
Análisis de agrupaciones, agregaciones y transformaciones de conjuntos para reporting y KPIs.
Preparación de queries complejas sin caer en LINQ críptico ni degradar demasiado la expresividad.
Detección de escenarios donde una navegación resuelve mejor que un join explícito y viceversa.
Revisión de cómo `GroupBy` se comporta según el proveedor y según la forma de usar la proyección final.
Construcción de patrones de consulta para informes, consolidaciones y vistas agregadas.
Taller de joins y agrupaciones avanzadas con .NET 10 y EF Core 10.

Tema 16: Traducción LINQ a SQL y lectura crítica del SQL generado

Comprensión de que escribir LINQ no significa delegar ciegamente el resultado final al proveedor sin revisarlo.
Revisión de cómo EF Core traduce árboles de expresión a SQL y de qué límites siguen existiendo en esa traducción.
Trabajo sobre cómo detectar cuándo una consulta LINQ es correcta en C# pero mala desde el punto de vista del SQL generado.
Preparación de hábitos para inspeccionar SQL, parámetros y shape final de la consulta antes de promoverla a producción.
Análisis del papel de la proyección, de los includes y de la cardinalidad en la complejidad del SQL resultante.
Detección de traducciones costosas, client evaluation no deseada y patrones que inflan el query plan.
Revisión de cómo las novedades de EF10 mejoran traducción en colecciones parametrizadas y joins modernos.
Construcción de una cultura de “query review” para equipos que dependen intensamente de EF Core.
Trabajo sobre cuándo abandonar LINQ momentáneamente y caer a SQL explícito con criterio.
Taller de análisis comparado entre LINQ escrito y SQL ejecutado.

Tema 17: Carga de datos relacionados: eager, explicit, lazy y filtered include

Revisión profunda de las tres formas principales de cargar datos relacionados en EF Core y sus implicaciones reales.
Diseño de estrategias de carga relacionadas con casos de uso concretos, no por costumbre o comodidad del desarrollador.
Trabajo sobre eager loading con `Include`, `ThenInclude` y filtered include sin sobredimensionar la consulta.
Análisis de explicit loading cuando interesa decidir más tarde si una navegación debe materializarse.
Revisión crítica de lazy loading y de por qué puede disparar el problema N+1 con enorme facilidad.
Preparación de un criterio claro para elegir cada estrategia según API, pantalla, batch o proceso interno.
Detección de consultas que cargan demasiado y de otras que cargan poco y fuerzan roundtrips adicionales.
Trabajo sobre split queries y lectura del impacto que tiene una colección cargada dentro de una sola consulta.
Revisión de cómo el tracking interactúa con filtered include y con la idea de navegación “considerada cargada”.
Taller de rediseño de una pantalla con problemas de carga relacionada.

Tema 18: Tracking, no-tracking, identity resolution y cambio de estado

Comprensión de qué gana y qué cuesta una query con tracking frente a una query sin tracking.
Revisión del funcionamiento del change tracker y de cómo mantiene identidad y estado de las entidades dentro del contexto.
Trabajo sobre escenarios donde el tracking es útil y otros donde solo aporta coste de memoria y CPU.
Preparación de estrategias `AsNoTracking`, `AsNoTrackingWithIdentityResolution` y defaults de contexto según tipo de carga.
Análisis del ciclo de vida de una entidad desde que se materializa hasta que cambia de estado y se persiste.
Detección de errores comunes al reusar entidades trackeadas en flujos largos o en varios contextos.
Revisión de cómo identity resolution afecta al grafo devuelto y a la semántica de la consulta.
Construcción de una intuición fuerte para decidir entre lectura pura, edición y mezcla de ambos escenarios.
Trabajo sobre attach, update, state management y riesgos de sobreescritura accidental.
Taller de gestión de estados y tracking sobre casos de edición reales.

Tema 19: Guardado de cambios, unidad de trabajo y semántica de persistencia

Revisión de cómo `SaveChanges` y `SaveChangesAsync` operan sobre el change tracker y el grafo de entidades.
Comprensión del coste y del valor del enfoque tradicional de persistencia basado en seguimiento de cambios.
Trabajo sobre inserciones, actualizaciones y borrados con control de estado explícito o implícito.
Preparación de una estrategia clara para comandos de aplicación que modifican varias entidades relacionadas.
Análisis de la unidad de trabajo como frontera transaccional lógica de una operación de negocio.
Detección de problemas al mezclar responsabilidades de lectura, validación y persistencia en lugares inadecuados.
Revisión de cómo guardar cambios de forma coherente cuando existen relaciones, cascadas y reglas de negocio.
Construcción de un flujo robusto para edición de agregados sin perder control del modelo.
Trabajo sobre errores frecuentes al persistir DTOs completos o grafos no controlados.
Taller de diseño de operaciones de escritura correctas y mantenibles.

Tema 20: ExecuteUpdate, ExecuteDelete y operaciones masivas sin tracking

Comprensión del papel de `ExecuteUpdate` y `ExecuteDelete` como alternativa al patrón clásico de cargar-entidad-modificar-guardar.
Revisión de escenarios donde estas operaciones son más eficientes porque actúan directamente en la base sin materializar entidades.
Trabajo sobre el impacto que tiene prescindir del change tracker y de `SaveChanges` en semántica y seguridad de negocio.
Preparación de actualizaciones y borrados masivos alineados con filtros LINQ expresivos.
Análisis de cuándo una operación bulk es correcta y cuándo rompe invariantes del dominio o auditoría esperada.
Detección de diferencias de comportamiento entre modificar entidades en memoria y emitir un `UPDATE` o `DELETE` directo.
Revisión de estrategias para combinar estas operaciones con transacciones, filtros globales y seguridad de aplicación.
Construcción de patrones de mantenimiento, archivado o recalculo sobre grandes volúmenes de datos.
Trabajo sobre medición de coste y rendimiento comparativo frente al enfoque tradicional.
Taller de refactor de procesos batch con `ExecuteUpdate` y `ExecuteDelete`.

Tema 21: SQL crudo, consultas parametrizadas y cuándo bajar de abstracción

Revisión de los escenarios donde LINQ no es la mejor herramienta y conviene caer a SQL explícito.
Trabajo sobre uso de `FromSql`, consultas SQL sobre tipos no mapeados y comandos relacionales con seguridad.
Preparación de consultas complejas, vistas, funciones o shapes especiales donde el SQL da más control que LINQ.
Análisis del equilibrio entre expresividad del ORM y necesidad de precisión quirúrgica en determinadas consultas.
Detección de riesgos de SQL injection y de malas prácticas al interpolar sin entender la parametrización.
Revisión de cómo mantener trazabilidad y mantenibilidad cuando parte de la lógica de acceso a datos vive en SQL.
Construcción de criterios claros para decidir entre LINQ, SQL crudo y extensiones específicas del proveedor.
Trabajo sobre encapsulación de consultas SQL para no contaminar capas superiores del sistema.
Preparación de una disciplina de revisión y testeo sobre queries escritas manualmente.
Taller de implementación de consultas avanzadas con SQL dentro de un proyecto EF Core.

Tema 22: Concurrencia, integridad y conflictos de escritura

Comprensión de por qué la concurrencia es un problema funcional y no solo técnico en sistemas multiusuario.
Revisión de tokens de concurrencia y estrategias para detectar que un dato cambió entre lectura y escritura.
Trabajo sobre cómo EF Core ayuda a evitar inconsistencias cuando varias instancias modifican los mismos registros.
Preparación de flujos de resolución de conflictos adaptados al tipo de negocio y al coste del error.
Análisis de escenarios donde dos usuarios cambian columnas distintas y de cómo decidir si eso es aceptable o no.
Detección de errores frecuentes al ignorar concurrencia hasta que el sistema entra en uso real.
Revisión de la relación entre concurrencia, experiencia de usuario y mensajes de error útiles.
Construcción de una metodología para testing de conflictos de escritura y de retry patterns razonables.
Trabajo sobre cómo no mezclar concurrencia optimista con falsa sensación de seguridad transaccional.
Taller de diseño de concurrencia en un caso empresarial crítico.

Tema 23: Transacciones, consistencia y límites operativos de la unidad de trabajo

Revisión de cuándo la transacción implícita de `SaveChanges` basta y cuándo el caso exige algo más explícito.
Trabajo sobre límites de consistencia cuando varias operaciones deben comportarse como una sola unidad lógica.
Preparación de flujos transaccionales que combinan EF Core, SQL y otras piezas de infraestructura.
Análisis del coste de ampliar demasiado el alcance transaccional y bloquear recursos sin necesidad.
Detección de operaciones que parecen seguras por ir “en el mismo método” pero no comparten una garantía real.
Revisión de cómo las transacciones afectan a tiempos, locks y recuperación ante error.
Construcción de criterios para encapsular trabajo transaccional en application services o handlers.
Trabajo sobre consistencia eventual frente a consistencia inmediata cuando el caso lo exige.
Preparación de mecanismos de rollback lógico y de registro de fallos para operaciones críticas.
Taller de diseño de una operación multientidad con control transaccional.

Tema 24: Performance real: consultas eficientes, split queries y shape de datos

Comprensión de que el principal rendimiento de EF Core se gana muchas veces en el diseño de la consulta y no en microoptimizar código C#.
Revisión de recomendaciones oficiales sobre querying eficiente: índices, shape de datos, carga relacionada y patrones de consulta.
Trabajo sobre selección de columnas, proyección temprana y reducción del ancho de fila como primera palanca de rendimiento.
Preparación de estrategias de split query cuando una sola query con muchas colecciones produce cartesian explosion o payload excesivo.
Detección de anti-patrones como `ToList()` prematuro, `Include` indiscriminado o filtros tardíos.
Revisión de cómo lazy loading puede disparar N+1 y de cómo evitarlo con diseño explícito de carga.
Construcción de un proceso de revisión de performance centrado en SQL, roundtrips y volumen de datos.
Trabajo sobre benchmarks simples y lectura de planes cuando el sistema empieza a sufrir.
Preparación de patrones de consulta rápidos para pantallas comunes de lectura intensiva.
Taller de optimización de consultas reales con métricas antes y después.

Tema 25: Consultas compiladas, modelos compilados y arranque optimizado

Revisión del papel de las consultas compiladas cuando una misma query se ejecuta muchas veces y el coste de compilación importa.
Comprensión de cómo EF Core puede compilar explícitamente consultas LINQ en delegados para evitar parte del pipeline repetitivo.
Trabajo sobre cuándo esta técnica merece la pena y cuándo añade complejidad sin beneficio apreciable.
Preparación de criterios para modelos compilados en aplicaciones con modelos especialmente grandes.
Revisión de cómo `dotnet ef dbcontext optimize` genera modelos compilados y consultas precompiladas.
Análisis del impacto del arranque del modelo en aplicaciones grandes con muchos tipos y relaciones.
Detección de casos donde el bottleneck no está en compilación de consultas sino en diseño de datos o red.
Construcción de una estrategia prudente para aplicar optimizaciones avanzadas de EF Core.
Trabajo sobre NativeAOT y por qué ciertas integraciones siguen siendo experimentales y no conviene sobrediseñarlas.
Taller de evaluación comparativa entre enfoque estándar y optimizaciones avanzadas.

Tema 26: Interceptores, logging, diagnóstico y observabilidad del acceso a datos

Uso de interceptores para observar, modificar o suprimir operaciones de EF Core en puntos bien definidos del pipeline.
Revisión de la diferencia entre logging simple, diagnóstico e interceptación real de operaciones.
Trabajo sobre interceptores de comandos, guardado, conexión e identidad cuando el caso de uso lo justifica.
Preparación de escenarios de auditoría, tagging, multi-tenant, validación o comportamiento transversal sobre consultas y escrituras.
Detección de abuso de interceptores para resolver problemas que deberían vivir en otra capa del sistema.
Revisión de la observabilidad del SQL emitido, tiempos, fallos y eventos relevantes para soporte y tuning.
Construcción de una estrategia de trazas útil para desarrollo, staging y producción sin ahogar la aplicación en ruido.
Trabajo sobre inspección de consultas lentas, errores de traducción y patrones problemáticos repetitivos.
Preparación de hooks técnicos para enriquecer logs y correlacionar operaciones de base de datos con requests o jobs.
Taller de instrumentación y diagnóstico de una capa de persistencia con EF Core.

Tema 27: Filtros globales, soft delete y multi-tenant con EF Core 10

Comprensión del valor de los filtros globales para aplicar criterios transversales a entidades sin repetir `Where` en todas las consultas.
Revisión de casos típicos como soft delete, aislamiento por tenant, visibilidad por estado o entornos lógicos.
Trabajo sobre cómo EF Core trata estos filtros como un `Where` LINQ adicional aplicado automáticamente.
Preparación de estrategias de diseño para no ocultar demasiado comportamiento al resto del equipo.
Detección de errores habituales al combinar filtros globales con queries complejas, includes o reportes administrativos.
Revisión de la novedad de named query filters en EF Core 10 para gestionar varios filtros de forma separable.
Construcción de una política de uso de filtros que mantenga seguridad y visibilidad del comportamiento del sistema.
Trabajo sobre cuándo ignorar filtros globales de forma controlada en casos administrativos o internos.
Preparación de pruebas para asegurar que soft delete y tenant isolation funcionan realmente en todo el modelo.
Taller de implementación de multi-tenant y soft delete con filtros globales.

Tema 28: Testing, dobles de persistencia y calidad de la capa de datos

Revisión de qué debe testearse realmente cuando se trabaja con EF Core y qué no conviene falsear demasiado.
Trabajo sobre diferencias entre tests unitarios puros, tests de integración con base real y pruebas con proveedores ligeros.
Preparación de escenarios de test para modelado, consultas, cambios de estado, concurrencia y migraciones.
Detección de falsos positivos cuando se testea contra entornos que no se comportan como el proveedor real.
Revisión del papel de SQLite in-memory o bases de prueba reales según lo que se quiere validar.
Construcción de una estrategia donde el acceso a datos se prueba con suficiente realismo sin volver el pipeline impracticable.
Trabajo sobre cómo diseñar seams de test sin encapsular EF Core detrás de abstracciones vacías.
Preparación de datos de prueba, limpieza de entornos y repetibilidad de suites.
Revisión de cómo validar SQL generado, tracking y efectos persistentes sin depender solo del “funciona”.
Taller de diseño de estrategia de testing para una solución con EF Core y LINQ.

Tema 29: Patrones de arquitectura: repositorio, specification, query objects y uso pragmático

Revisión crítica del patrón repositorio encima de EF Core y de cuándo aporta valor real frente a cuándo solo duplica el ORM.
Trabajo sobre specification pattern, query objects y servicios de consulta como alternativas más expresivas para casos complejos.
Preparación de una arquitectura pragmática que no esconda `IQueryable` de forma irresponsable ni lo exponga sin control.
Análisis de cómo separar comandos, consultas y lógica de dominio sin crear un laberinto de capas artificiales.
Detección de repositorios genéricos vacíos que dificultan más de lo que ayudan.
Revisión de cómo organizar consultas complejas reutilizables sin sacrificar legibilidad ni testabilidad.
Construcción de criterios claros para decidir qué abstraer y qué dejar directamente sobre EF Core.
Trabajo sobre bounded contexts, módulos y ownership de persistencia en aplicaciones grandes.
Preparación de un estilo de arquitectura alineado con el equipo, el producto y la complejidad real.
Taller de refactor arquitectónico de una capa de datos con anti-patrones habituales.

Tema 30: Proyecto final integrador de Entity Framework y LINQ en .NET 10

Selección de un caso real de backend o módulo corporativo con suficiente complejidad de modelado, consultas y escritura.
Diagnóstico del punto de partida en entidades, relaciones, queries, migraciones, performance y calidad arquitectónica.
Diseño del modelo EF Core 10 con entidades, configuraciones, relaciones, claves y decisiones de dominio bien justificadas.
Construcción de queries LINQ para listados, búsqueda, detalle, reporting y escritura con lectura crítica del SQL generado.
Implementación de migraciones, seeding, filtros globales, tracking adecuado y una estrategia de concurrencia coherente.
Optimización de consultas críticas mediante proyecciones, includes razonables, split queries o estrategias alternativas.
Añadido de logging, interceptores o diagnóstico allí donde el caso lo requiera.
Diseño de tests de integración y de un plan de despliegue de cambios de esquema razonable.
Presentación del caso con enfoque técnico, arquitectónico y de mantenibilidad a medio plazo.
Entrega de un blueprint reusable para aplicar EF Core y LINQ con estándar profesional en otros proyectos .NET 10.

Preguntas frecuentes

Resolvemos todas tus dudas sobre nuestra formación en Entity Framework y LinQ

Explora las respuestas a las preguntas que guian a nuestra comunidad. Aqui encontraras claridad sobre como funciona todo, desde el acceso hasta los detalles de los cursos. Si buscas respuestas, este es el lugar para comenzar.

Está claramente centrado en Entity Framework Core 10 dentro de .NET 10. La documentación oficial describe EF Core como el ORM moderno para .NET, con soporte para LINQ, tracking, updates y migrations, y alineado con los ciclos de soporte de .NET. EF10 además es LTS y requiere .NET 10 para compilar y ejecutar.

¿Tienes dudas?
Estamos aqui para ayudarte

Contactar

¿Tienes dudas?
Estamos aqui para ayudarte

Contactar

Curso de Entity Framework y LinQ para Equipos de Desarrollo

Aprende con el curso de Entity Framework y LinQ para empresas hasta 100% bonificado, a medida para tu organización.

¿Qué es FUNDAE?

¿Cómo funciona FUNDAE?

¿Cómo se bonifica un curso?

¿Qué es FUNDAE?

¿Cómo funciona FUNDAE?

¿Cómo se bonifica un curso?

¿Qué es FUNDAE?

¿Cómo funciona FUNDAE?

¿Cómo se bonifica un curso?

Curso de Entity Framework y LinQ hasta 100% Bonificable a través de FUNDAE

Tu bonificación paso a paso

La formación que decides
te devuelve dinero

Convierte EF Core y LINQ en una capacidad técnica seria del equipo

Personaliza el temario al 100% para tu equipo

Nueva Plataforma
de E-learningFormación en directo con plataforma de apoyo para reforzar el aprendizaje

Acceso a las grabaciones

Recursos formativos

Confirmación de asistencia

Temario del curso

Pensado para quienes deben dominar Entity Framework y LinQ en su día a día

Resolvemos todas tus dudas sobre nuestra formación en Entity Framework y LinQ

Diseñemos hoy el curso que tu empresa necesita

Ejercicios prácticos

Acceso a las grabaciones

Recursos formativos

Confirmación de asistencia

Ejercicios prácticos

Practica y mejora con nuestra plataforma

Curso de Entity Framework y LinQ para Equipos de Desarrollo

Aprende con el curso de Entity Framework y LinQ para empresas hasta 100% bonificado, a medida para tu organización.

Curso de Entity Framework y LinQ hasta 100% Bonificable a través de FUNDAE

Tu bonificación paso a paso

La formación que decideste devuelve dinero

Convierte EF Core y LINQ en una capacidad técnica seria del equipo

Personaliza el temario al 100% para tu equipo

Nueva Plataformade E-learningFormación en directo con plataforma de apoyo para reforzar el aprendizaje

Acceso a las grabaciones

Recursos formativos

Confirmación de asistencia

Temario del curso

Pensado para quienes deben dominar Entity Framework y LinQ en su día a día

Resolvemos todas tus dudas sobre nuestra formación en Entity Framework y LinQ

Diseñemos hoy el curso que tu empresa necesita

Ejercicios prácticos

Acceso a las grabaciones

Recursos formativos

Confirmación de asistencia

Ejercicios prácticos

Practica y mejora con nuestra plataforma

La formación que decides
te devuelve dinero

Nueva Plataforma
de E-learningFormación en directo con plataforma de apoyo para reforzar el aprendizaje