Permite crear aplicaciones web completas con C# y .NET
Capacita a tu equipo en Blazor con un plan formativo A Medida, tutorizado y bonificable hasta el 100% por FUNDAE para empresas con casos prácticos. Contáctanos.
Enseña a elegir el render mode correcto El curso no asume que todo debe ser Server o WebAssembly. Se trabajan SSR, Interactive Server, WebAssembly y Auto para que cada pantalla use el modelo que mejor equilibra seguridad, rendimiento, UX y mantenibilidad.
1
Personaliza el temario al 100% para tu equipo
Diseñamos una formación a medida utilizando los documentos y flujos de trabajo reales de tu empresa.
Nueva Plataforma de E-learningFormación en directo con plataforma de apoyo para reforzar el aprendizaje
Acceso a las grabaciones
Los alumnos podrán revisar las sesiones grabadas para repasar conceptos clave, recuperar explicaciones concretas o reforzar aquellos contenidos que necesiten después de la clase en directo.
Recursos formativos
Materiales, sesiones grabadas y documentación de apoyo quedan centralizados en la plataforma para que el equipo pueda consultarlos durante y después de la formación.
Confirmación de asistencia
La plataforma permite registrar y confirmar la asistencia de los participantes, facilitando el seguimiento de la formación y la gestión documental necesaria para la bonificación FUNDAE.
Programa formativo
Temario del curso
Encuentra todo el temario del curso aquí.
Temario
Comprensión de Blazor como framework de UI basado en componentes Razor, capaz de construir interfaces web interactivas usando C# y .NET en lugar de depender exclusivamente de JavaScript.
Diferenciación entre Blazor Web App, Blazor Server, Blazor WebAssembly, componentes Razor reutilizables y Blazor Hybrid para tomar decisiones correctas según contexto empresarial.
Revisión del papel de Blazor dentro de ASP.NET Core 10.0, incluyendo su relación con middleware, routing, static files, autenticación, DI, configuración y hosting.
Análisis de escenarios donde Blazor aporta valor real: backoffices, portales internos, herramientas de gestión, dashboards, formularios complejos y aplicaciones corporativas.
Identificación de casos donde Blazor puede no ser la mejor opción: frontends públicos muy pesados, equipos muy especializados en SPA JavaScript o necesidades extremas de SEO avanzado.
Evaluación de ventajas para equipos .NET: reutilización de C#, shared models, validaciones, servicios, librerías, testing y conocimiento del ecosistema Microsoft.
Separación entre productividad inicial y mantenibilidad a largo plazo, evitando aplicaciones Blazor que crecen sin arquitectura clara.
Revisión de cómo Blazor se integra con APIs internas, bases de datos, servicios de identidad, colas, observabilidad y despliegues cloud.
Preparación de una hoja de ruta de aprendizaje desde componentes básicos hasta aplicaciones productivas con seguridad, pruebas y CI/CD.
Definición de criterios para elegir Blazor en un proyecto empresarial con base en equipo, dominio, experiencia, rendimiento, seguridad y coste de mantenimiento.
Comprensión de Blazor como framework de UI basado en componentes Razor, capaz de construir interfaces web interactivas usando C# y .NET en lugar de depender exclusivamente de JavaScript.
Diferenciación entre Blazor Web App, Blazor Server, Blazor WebAssembly, componentes Razor reutilizables y Blazor Hybrid para tomar decisiones correctas según contexto empresarial.
Revisión del papel de Blazor dentro de ASP.NET Core 10.0, incluyendo su relación con middleware, routing, static files, autenticación, DI, configuración y hosting.
Análisis de escenarios donde Blazor aporta valor real: backoffices, portales internos, herramientas de gestión, dashboards, formularios complejos y aplicaciones corporativas.
Identificación de casos donde Blazor puede no ser la mejor opción: frontends públicos muy pesados, equipos muy especializados en SPA JavaScript o necesidades extremas de SEO avanzado.
Evaluación de ventajas para equipos .NET: reutilización de C#, shared models, validaciones, servicios, librerías, testing y conocimiento del ecosistema Microsoft.
Separación entre productividad inicial y mantenibilidad a largo plazo, evitando aplicaciones Blazor que crecen sin arquitectura clara.
Revisión de cómo Blazor se integra con APIs internas, bases de datos, servicios de identidad, colas, observabilidad y despliegues cloud.
Preparación de una hoja de ruta de aprendizaje desde componentes básicos hasta aplicaciones productivas con seguridad, pruebas y CI/CD.
Definición de criterios para elegir Blazor en un proyecto empresarial con base en equipo, dominio, experiencia, rendimiento, seguridad y coste de mantenimiento.
Tema 1: Blazor dentro del ecosistema ASP.NET Core moderno
Comprensión de Blazor como framework de UI basado en componentes Razor, capaz de construir interfaces web interactivas usando C# y .NET en lugar de depender exclusivamente de JavaScript.
Diferenciación entre Blazor Web App, Blazor Server, Blazor WebAssembly, componentes Razor reutilizables y Blazor Hybrid para tomar decisiones correctas según contexto empresarial.
Revisión del papel de Blazor dentro de ASP.NET Core 10.0, incluyendo su relación con middleware, routing, static files, autenticación, DI, configuración y hosting.
Análisis de escenarios donde Blazor aporta valor real: backoffices, portales internos, herramientas de gestión, dashboards, formularios complejos y aplicaciones corporativas.
Identificación de casos donde Blazor puede no ser la mejor opción: frontends públicos muy pesados, equipos muy especializados en SPA JavaScript o necesidades extremas de SEO avanzado.
Evaluación de ventajas para equipos .NET: reutilización de C#, shared models, validaciones, servicios, librerías, testing y conocimiento del ecosistema Microsoft.
Separación entre productividad inicial y mantenibilidad a largo plazo, evitando aplicaciones Blazor que crecen sin arquitectura clara.
Revisión de cómo Blazor se integra con APIs internas, bases de datos, servicios de identidad, colas, observabilidad y despliegues cloud.
Preparación de una hoja de ruta de aprendizaje desde componentes básicos hasta aplicaciones productivas con seguridad, pruebas y CI/CD.
Definición de criterios para elegir Blazor en un proyecto empresarial con base en equipo, dominio, experiencia, rendimiento, seguridad y coste de mantenimiento.
Tema 2: Estructura de proyectos Blazor Web App en .NET 10
Creación de una Blazor Web App moderna y análisis de la estructura generada por la plantilla oficial de ASP.NET Core.
Comprensión de la plantilla Blazor Web App como punto de partida único para crear UI con Razor Components combinando renderizado server-side y client-side.
Revisión de carpetas habituales: Components, Pages, Layout, wwwroot, Program.cs, App.razor, routes, imports y configuración del proyecto.
Análisis del proyecto `.Client` cuando se habilita renderizado WebAssembly o Interactive Auto, entendiendo qué componentes deben vivir en esa capa.
Organización de componentes por dominio funcional, evitando estructuras planas donde todo termina en carpetas genéricas difíciles de navegar.
Separación entre componentes de página, componentes de layout, componentes reutilizables, servicios de aplicación y modelos compartidos.
Configuración de namespaces, `_Imports.razor`, static web assets y referencias entre proyectos.
Diseño de una estructura preparada para crecer con varios equipos, módulos, librerías Razor y responsabilidades diferenciadas.
Revisión de errores frecuentes de organización: lógica de negocio en componentes, servicios duplicados, CSS disperso y modelos acoplados a UI.
Definición de una plantilla corporativa base para nuevos proyectos Blazor, incluyendo naming, carpetas, comandos, tests y documentación mínima.
Tema 3: Razor Components: composición, parámetros y reutilización
Creación de componentes Razor con markup, código C#, parámetros, eventos, contenido hijo y estilos asociados.
Diseño de componentes pequeños, expresivos y reutilizables que no mezclan presentación, acceso a datos y reglas de negocio.
Uso de `[Parameter]` para entrada de datos, `EventCallback` para comunicación hacia el padre y `RenderFragment` para composición flexible.
Gestión de parámetros obligatorios, valores por defecto, cambios de estado y validación de contratos entre componentes.
Aplicación de `CascadingParameter` y cascading values cuando existe contexto compartido como tema, usuario, configuración o estado de layout.
Identificación de cuándo un componente debe ser genérico, cuándo debe ser específico del dominio y cuándo conviene dividirlo.
Creación de componentes corporativos: tarjetas, tablas, filtros, formularios, selectores, barras de acciones, modales y mensajes de error.
Uso de partial classes para separar markup y lógica cuando el componente crece sin convertirlo en una clase difícil de seguir.
Revisión de anti-patrones: componentes gigantes, dependencia directa de APIs, demasiados parámetros, estado duplicado y renderizados innecesarios.
Definición de una guía de componentes reutilizables con convenciones, ejemplos, criterios de test y documentación.
Tema 4: Ciclo de vida de componentes y renderizado
Comprensión de los métodos de ciclo de vida de componentes, desde inicialización hasta renderizado, actualización de parámetros y liberación de recursos.
Uso correcto de `OnInitialized`, `OnInitializedAsync`, `OnParametersSet`, `OnAfterRender`, `ShouldRender` y `Dispose`.
Diferenciación entre inicialización del componente, carga de datos, respuesta a cambios de parámetros y lógica posterior al render.
Prevención de llamadas duplicadas, bucles de renderizado, estados inconsistentes y cargas innecesarias de datos.
Gestión de operaciones asíncronas con cancelación, loading states, errores y cambios de navegación.
Control de renderizados costosos en componentes con tablas, listas, gráficos, formularios grandes o dependencias externas.
Uso de `@key` para mejorar identidad de elementos en listas dinámicas y evitar comportamientos inesperados.
Revisión de cómo prerendering y modos interactivos afectan a inicialización, estado y llamadas al servidor.
Preparación de componentes robustos que soportan navegación rápida, recarga, reconexión y cambios de parámetros.
Creación de una checklist de ciclo de vida para evitar bugs difíciles de reproducir en producción.
Tema 5: Render modes: Static SSR, Interactive Server, WebAssembly y Auto
Comprensión de los render modes como mecanismo que determina dónde se renderiza un componente, cómo se vuelve interactivo y qué modelo de ejecución utiliza.
Diferenciación entre Static SSR, Interactive Server, Interactive WebAssembly e Interactive Auto para escoger el modo adecuado por componente.
Aplicación de `@rendermode` en componentes o instancias, valorando impacto en rendimiento, interactividad, latencia, carga inicial y arquitectura.
Diseño de páginas donde una parte permanece estática y otra se vuelve interactiva para reducir carga innecesaria.
Uso de Interactive Server en escenarios de baja carga inicial, acceso seguro al servidor, lógica sensible o dependencia fuerte de recursos backend.
Uso de Interactive WebAssembly cuando se necesita ejecución cliente, menor dependencia de conexión persistente y experiencia más cercana a SPA.
Uso de Interactive Auto para combinar interactividad inicial en servidor y transición posterior a WebAssembly cuando el runtime ya está disponible.
Identificación de restricciones del proyecto `.Client` para componentes WebAssembly o Auto, evitando ubicar código en el proyecto incorrecto.
Análisis de problemas típicos: servicios no disponibles, diferencias server/client, duplicidad de ejecución y estado perdido tras prerendering.
Creación de una matriz de decisión de render modes para proyectos empresariales con criterios de seguridad, UX, coste y mantenibilidad.
Tema 6: Routing, layouts y navegación avanzada
Configuración de rutas mediante componentes Razor, parámetros de ruta, constraints y organización de páginas.
Diseño de layouts corporativos con navegación lateral, cabecera, breadcrumbs, zonas de usuario, menús por permiso y contenido principal.
Uso de `NavLink`, `NavigationManager`, parámetros de query string y navegación programática.
Gestión de rutas protegidas, rutas públicas, páginas de error, páginas no encontradas y redirecciones controladas.
Aplicación de enhanced navigation cuando procede para mejorar experiencia de usuario sin introducir comportamientos inesperados.
Diseño de navegación en aplicaciones internas con módulos, áreas funcionales, permisos y rutas profundas.
Sincronización entre filtros, URL, query parameters y estado de la página para permitir compartir enlaces útiles.
Gestión de confirmaciones antes de abandonar formularios con cambios pendientes.
Revisión de patrones de navegación en aplicaciones con dashboards, master-detail, wizard forms y procesos largos.
Creación de una guía de navegación que combine usabilidad, accesibilidad, SEO cuando aplique y mantenibilidad.
Tema 7: Formularios, validación y experiencia de entrada de datos
Construcción de formularios Blazor con `EditForm`, modelos, validadores, mensajes de error y control del ciclo de envío.
Uso de Data Annotations y validación personalizada para reglas simples, cruzadas y dependientes del contexto.
Diseño de formularios empresariales con secciones, pasos, estados parciales, campos condicionales y validación progresiva.
Integración de validación de servidor cuando las reglas dependen de base de datos, permisos, duplicados o lógica de negocio.
Gestión de errores de API dentro del formulario, mostrando mensajes útiles sin exponer detalles técnicos.
Control de estados como guardando, guardado, error, borrador, cambios pendientes y reintentos.
Aplicación de validación mejorada de formularios disponible en ASP.NET Core 10.0 como parte de las mejoras documentadas para .NET 10.
Creación de componentes reutilizables para campos, selectores, errores, tooltips, ayudas, máscaras y validación común.
Revisión de accesibilidad en formularios: labels, foco, mensajes, navegación por teclado y lectores de pantalla.
Diseño de una estrategia de formularios para aplicaciones internas con alta carga de datos, permisos y procesos de aprobación.
Tema 8: Estado en Blazor: local, compartido, persistente y de sesión
Diferenciación entre estado local del componente, estado compartido, estado de navegación, estado persistente y estado de servidor.
Diseño de servicios scoped para compartir estado entre componentes dentro de una sesión o circuito.
Gestión de estado en render modes interactivos, prestando atención a diferencias entre servidor, WebAssembly y prerendering.
Uso de persistent component state para conservar datos entre prerenderizado e interactividad cuando el escenario lo requiere.
Aplicación de almacenamiento local o session storage cuando tiene sentido, sin guardar información sensible de forma insegura.
Prevención de problemas por singleton state en aplicaciones server-side, especialmente cuando puede mezclarse información entre usuarios.
Diseño de state containers explícitos para filtros, selección, preferencias de usuario, wizard forms o dashboards.
Sincronización de estado con URL cuando el usuario necesita compartir enlaces, volver atrás o recuperar filtros.
Control de caducidad, recarga, reconexión y recuperación de estado ante errores o navegación.
Creación de una guía de gestión de estado con criterios de seguridad, UX, testabilidad y simplicidad.
Tema 9: Servicios, dependency injection y lógica de aplicación
Uso de dependency injection en Blazor para registrar servicios, clientes HTTP, repositorios, casos de uso, adaptadores y configuración.
Separación entre componentes visuales y lógica de aplicación para evitar que las páginas acumulen acceso a datos, reglas y validaciones complejas.
Diseño de servicios por responsabilidad: consulta, comando, sesión, notificación, permisos, configuración, navegación y estado compartido.
Configuración de lifetimes `Singleton`, `Scoped` y `Transient` entendiendo sus implicaciones en Blazor Server, WebAssembly y Web App.
Prevención de fugas de estado entre usuarios, especialmente en servicios compartidos o caches mal diseñadas.
Uso de options pattern, configuración por entorno y servicios fuertemente tipados.
Creación de adaptadores para APIs externas, servicios internos, almacenamiento local, autenticación y telemetría.
Diseño de servicios testables, con interfaces claras, mocks razonables y mínima dependencia de componentes UI.
Revisión de anti-patrones: inyección excesiva en componentes, servicios gigantes, lógica duplicada y dependencias circulares.
Definición de estándares corporativos para servicios Blazor, composición de dependencias y estructura de aplicación.
Tema 10: Consumo de APIs y comunicación cliente-servidor
Consumo de APIs REST desde componentes y servicios Blazor usando `HttpClient`, clientes tipados y manejo robusto de errores.
Diseño de contratos entre frontend Blazor y APIs backend con DTOs, códigos HTTP, validaciones, errores y versionado.
Gestión de autenticación al llamar APIs, incorporando tokens, cookies, handlers, named clients y protección antiforgery cuando aplica.
Preparación de respuestas de error coherentes para que la UI pueda mostrar mensajes útiles y acciones correctivas.
Implementación de loading states, retry controlado, cancelación, timeouts y mensajes de fallo.
Uso de streaming o carga progresiva cuando hay listados grandes, informes pesados o datos que tardan en generarse.
Diseño de servicios de cliente que encapsulan llamadas API y evitan duplicar lógica HTTP en componentes.
Integración con Minimal APIs, controllers, endpoints internos y servicios de dominio existentes.
Revisión de problemas frecuentes: llamadas duplicadas durante prerendering, tokens caducados, CORS, antiforgery y errores no controlados.
Creación de una estrategia de integración API para aplicaciones Blazor empresariales con seguridad, observabilidad y mantenibilidad.
Tema 11: Autenticación, autorización y seguridad de acceso
Configuración de autenticación y autorización en Blazor usando los mecanismos existentes de ASP.NET Core, ajustados al modelo de hosting.
Diferenciación entre controles de autorización ejecutados en servidor y controles visuales ejecutados en cliente, evitando confiar en lógica client-side para proteger recursos críticos.
Aplicación de políticas, roles, claims, permisos por recurso y autorización basada en requisitos.
Uso de `AuthorizeView`, rutas protegidas, servicios de estado de autenticación y control de UI según usuario.
Integración con ASP.NET Core Identity, Microsoft Entra ID, OpenID Connect, cookies, JWT o Windows Authentication según entorno corporativo.
Diseño de flujos de login, logout, renovación, sesión expirada, error de permisos y navegación postautenticación.
Protección de formularios, endpoints, APIs y recursos sensibles con antiforgery, validación de entrada y control de permisos server-side.
Revisión de advertencias de seguridad: el código client-side puede ser manipulado y no debe usarse como única barrera de autorización.
Gestión de identidad en aplicaciones internas con multirol, multitenant, permisos por módulo y auditoría.
Creación de una checklist de seguridad Blazor para rutas, componentes, APIs, formularios, estado, logs y datos sensibles.
Tema 12: Autorización avanzada, multitenancy y seguridad por recurso
Diseño de autorización granular por tenant, organización, departamento, proyecto, recurso o registro concreto.
Implementación de políticas que combinan claims, roles, ownership, estado del recurso y reglas de negocio.
Separación entre permisos de visualización, edición, aprobación, exportación, administración y acceso a datos sensibles.
Evitación de controles solo visuales que ocultan botones pero permiten acceder a endpoints o datos sin autorización real.
Diseño de componentes que reciben permisos ya evaluados o consultan servicios de autorización de forma controlada.
Gestión de escenarios multitenant con aislamiento de datos, validación server-side y prevención de acceso cruzado.
Aplicación de auditoría sobre acciones críticas: creación, modificación, aprobación, exportación, eliminación y cambios de permisos.
Revisión de caches de permisos para no servir autorizaciones obsoletas en sesiones largas.
Creación de tests de autorización para rutas, APIs, componentes y casos límite.
Documentación de matriz de permisos para que negocio, seguridad y desarrollo compartan la misma interpretación.
Tema 13: JavaScript interop, DOM y librerías externas
Uso de JavaScript interop para integrar librerías, APIs del navegador o funcionalidades no disponibles directamente en Blazor.
Diseño de wrappers C# sobre llamadas JavaScript para evitar invocaciones dispersas y difíciles de mantener.
Gestión de módulos JavaScript, importación dinámica, referencias a elementos, eventos DOM y ciclo de vida del componente.
Evitación de manipulación directa del DOM que entra en conflicto con el renderizado de Blazor.
Integración de librerías de gráficos, mapas, editores, calendarios, lectores de archivos o componentes visuales especializados.
Control de errores, cancelación, dispose y liberación de recursos en interop para evitar fugas de memoria.
Diseño de contratos claros entre C# y JavaScript con DTOs, serialización y validación de datos.
Revisión de seguridad en interop: XSS, datos no confiables, HTML dinámico, scripts externos y permisos del navegador.
Creación de componentes Blazor que encapsulan interop para ofrecer una API limpia al resto del equipo.
Definición de criterios para decidir entre componente nativo Blazor, librería JavaScript integrada o solución externa.
Tema 14: Componentes de UI, CSS, diseño y accesibilidad
Diseño de interfaces Blazor con componentes reutilizables, estilos coherentes y separación clara entre estructura, comportamiento y presentación.
Uso de CSS isolation, clases globales, design tokens, temas y convenciones para mantener consistencia visual.
Construcción de layouts adaptativos, grids, barras de navegación, modales, paneles laterales, tablas, filtros y componentes de feedback.
Integración con frameworks CSS o librerías de componentes cuando aportan valor y no generan dependencia excesiva.
Aplicación de accesibilidad desde el inicio: semántica HTML, foco, teclado, contraste, roles ARIA y mensajes comprensibles.
Creación de componentes de formulario accesibles con labels, descripciones, errores, estados y navegación correcta.
Revisión de diseño responsive para aplicaciones internas usadas en escritorio, tablet o dispositivos concretos.
Evitación de componentes visuales demasiado genéricos que complican personalización o rompen usabilidad.
Documentación de una librería interna de componentes con ejemplos, parámetros, estados y criterios de uso.
Medición de calidad de UI por claridad, consistencia, accesibilidad, reducción de errores y satisfacción de usuarios internos.
Tema 15: Tablas, QuickGrid, datos paginados y dashboards
Construcción de tablas empresariales con paginación, ordenación, filtros, selección, acciones por fila y estados de carga.
Uso de QuickGrid cuando encaja como componente de tabla para escenarios de datos tabulares, incorporando mejoras actuales como `RowClass` en .NET 10.
Diseño de listados conectados a APIs con paginación server-side, filtros persistentes y parámetros en URL.
Gestión de grandes volúmenes de datos evitando cargar todo en memoria o renderizar miles de filas sin estrategia.
Implementación de dashboards con tarjetas KPI, gráficos, tablas, drill-down, filtros globales y actualización controlada.
Control de permisos sobre columnas, acciones, exportaciones y datos sensibles en vistas de negocio.
Diseño de experiencias master-detail para editar registros sin perder contexto de filtros y navegación.
Integración con APIs de reporting, BI, exportación a CSV/Excel o generación de informes cuando el caso lo requiere.
Revisión de rendimiento en listados con renderizado frecuente, componentes anidados y estado compartido.
Creación de patrones corporativos para grids, dashboards y pantallas de gestión recurrentes.
Tema 16: Blazor WebAssembly: arquitectura cliente, carga y rendimiento
Comprensión de Blazor WebAssembly como ejecución de componentes en el navegador mediante runtime .NET descargado al cliente.
Diseño de aplicaciones o módulos donde la ejecución cliente aporta valor por interactividad, menor latencia percibida o trabajo offline parcial.
Análisis de coste de carga inicial, tamaño del bundle, dependencias, trimming, lazy loading y preloading.
Aplicación de Blazor WebAssembly preloading como mejora documentada en .NET 10 para optimizar experiencia de carga.
Separación entre código que puede ejecutarse en cliente y código que debe permanecer en servidor por seguridad, secretos o acceso a datos.
Gestión de autenticación, tokens, llamadas API, CORS, expiración de sesión y errores de red en WebAssembly.
Diseño de componentes compartidos entre servidor y cliente evitando dependencias no compatibles con WebAssembly.
Control de consumo de memoria, operaciones pesadas, serialización y renderizados costosos.
Revisión de escenarios donde WebAssembly no encaja por requisitos de seguridad, carga inicial o dependencia fuerte de recursos del servidor.
Creación de una matriz de decisión para elegir WebAssembly frente a Interactive Server o Auto.
Tema 17: Blazor Server e Interactive Server: circuitos, SignalR y escalabilidad
Comprensión de Interactive Server y Blazor Server como modelos donde la interactividad se mantiene mediante conexión SignalR y estado en servidor.
Análisis de circuitos, reconexión, latencia, memoria por usuario, escalado horizontal y afinidad de sesión.
Diseño de aplicaciones internas donde Interactive Server aporta productividad, seguridad de lógica server-side y menor carga inicial.
Gestión de pérdida de conexión, reintentos, mensajes al usuario y recuperación de estado.
Prevención de problemas de estado compartido entre usuarios, especialmente con servicios singleton o caches mal planteadas.
Optimización de componentes para reducir tráfico, renderizados y actualizaciones innecesarias por circuito.
Configuración de hosting, balanceo, SignalR, sticky sessions o backplanes cuando la arquitectura lo requiere.
Revisión de impacto de usuarios concurrentes, memoria, operaciones largas y servicios bloqueantes.
Aplicación de observabilidad para detectar desconexiones, errores de circuito, latencia y consumo de recursos.
Definición de límites de uso de Interactive Server según criticidad, escala, red, UX y costes operativos.
Tema 18: Blazor Hybrid con .NET MAUI y reutilización de Razor Components
Comprensión de Blazor Hybrid como opción para ejecutar componentes Razor dentro de aplicaciones nativas mediante WebView.
Uso de BlazorWebView en .NET MAUI, donde los componentes Razor se ejecutan en el proceso .NET y se renderizan en una web view embebida.
Revisión de escenarios empresariales: aplicaciones de escritorio internas, herramientas offline parciales, integración con capacidades del dispositivo y reutilización de UI.
Diseño de librerías Razor compartidas entre Blazor Web App y aplicaciones MAUI Blazor Hybrid.
Separación de lógica reutilizable, servicios específicos de plataforma y componentes UI compartidos.
Integración con funcionalidades nativas: archivos, cámara, almacenamiento local, notificaciones, impresión o acceso a dispositivo cuando procede.
Revisión de consideraciones de seguridad al mezclar contenido web, WebView y código nativo.
Gestión de distribución, actualización, versiones, configuración y soporte en aplicaciones desktop o mobile corporativas.
Identificación de límites frente a aplicaciones web puras, MAUI nativo o SPA tradicional.
Creación de una estrategia de reutilización de componentes Razor para web, desktop y mobile sin duplicar código innecesariamente.
Tema 19: Librerías Razor, componentes corporativos y diseño modular
Creación de Razor Class Libraries para compartir componentes, layouts, recursos estáticos, estilos, validadores y utilidades entre aplicaciones.
Diseño de una librería corporativa de UI con componentes consistentes, accesibles, testados y documentados.
Separación entre librerías visuales, librerías de dominio, clientes API, servicios compartidos y utilidades transversales.
Gestión de versiones NuGet internas, compatibilidad, changelog, breaking changes y documentación de componentes.
Uso de static web assets para distribuir CSS, JavaScript, imágenes y recursos de componentes reutilizables.
Diseño de componentes configurables sin convertirlos en piezas imposibles de entender por exceso de parámetros.
Preparación de ejemplos, stories, páginas de demo o documentación técnica para facilitar adopción.
Revisión de dependencias externas para evitar que la librería corporativa arrastre peso, licencias o riesgos innecesarios.
Creación de pruebas sobre componentes compartidos para evitar regresiones en varias aplicaciones.
Definición de un modelo de gobierno para aceptar nuevos componentes, deprecar antiguos y mantener consistencia.
Tema 20: Testing de componentes, servicios y flujos Blazor
Diseño de una estrategia de testing que cubra componentes, servicios, formularios, validaciones, autorización, APIs y navegación.
Uso de pruebas unitarias para servicios, modelos, validadores, mappers y lógica independiente de UI.
Creación de pruebas de componentes con herramientas adecuadas para verificar renderizado, eventos, parámetros, formularios y cambios de estado.
Simulación de servicios, autenticación, permisos, navegación y llamadas API sin depender de sistemas externos reales.
Preparación de pruebas de integración para flujos críticos como login, envío de formularios, edición, aprobación o exportación.
Uso de pruebas end-to-end cuando el flujo completo debe validarse desde navegador, backend y base de datos.
Detección de regresiones visuales o funcionales en componentes reutilizables.
Integración de tests en CI/CD con reportes claros, cobertura útil y bloqueo de cambios críticos.
Evitación de tests frágiles que dependen demasiado de detalles internos o markup no relevante.
Creación de una pirámide de testing específica para aplicaciones Blazor empresariales.
Tema 21: Rendimiento, carga inicial y optimización de experiencia
Análisis de rendimiento en Blazor desde varias dimensiones: carga inicial, renderizado, llamadas API, memoria, latencia y tamaño de recursos.
Optimización de componentes para evitar renderizados innecesarios, listas pesadas y cálculos repetidos dentro del ciclo de UI.
Uso prudente de `ShouldRender`, `@key`, virtualización, paginación y carga diferida.
Optimización de Blazor WebAssembly mediante trimming, lazy loading, preloading y control de dependencias.
Revisión del impacto de static web assets, compresión, fingerprinting y caché del navegador.
Diseño de indicadores de rendimiento para aplicaciones internas: tiempo hasta interacción, latencia de acciones, errores y consumo de recursos.
Análisis de problemas de Interactive Server: latencia, circuitos, reconexiones, memoria y tráfico SignalR.
Reducción de llamadas API duplicadas, especialmente en escenarios con prerendering o cambios de parámetros.
Uso de herramientas de diagnóstico del navegador, logs de servidor, métricas, traces y profiling.
Creación de una checklist de rendimiento Blazor para revisar antes de producción.
Tema 22: Observabilidad, logging, diagnóstico y soporte en producción
Integración de logging estructurado en componentes, servicios, APIs y flujos críticos de usuario.
Uso de correlation IDs para conectar acciones de UI, llamadas API, errores backend y operaciones de base de datos.
Configuración de métricas y trazas para detectar lentitud, errores, desconexiones, fallos de autenticación y problemas de carga.
Aprovechamiento de diagnósticos mejorados disponibles en ASP.NET Core 10.0 como parte de la evolución documentada de .NET 10.
Diseño de mensajes de error para usuario que sean útiles sin revelar detalles técnicos o información sensible.
Preparación de runbooks para errores frecuentes: fallo de autenticación, API caída, circuito desconectado, validación rota o despliegue defectuoso.
Integración con Application Insights, OpenTelemetry, dashboards, alertas o herramientas corporativas equivalentes.
Gestión de logs client-side cuando se trabaja con WebAssembly o errores de navegador.
Creación de indicadores de salud para aplicaciones Blazor: errores, latencia, carga, usuarios activos y operaciones críticas.
Definición de un modelo de soporte donde desarrollo, DevOps y negocio entienden qué datos revisar ante una incidencia.
Tema 23: DevOps, CI/CD y despliegue de aplicaciones Blazor
Creación de pipelines para restaurar, compilar, probar, publicar y desplegar aplicaciones Blazor en entornos corporativos.
Configuración de builds diferenciados para servidor, cliente WebAssembly, librerías Razor, tests y artefactos estáticos.
Gestión de configuración por entorno: desarrollo, integración, preproducción, producción y entornos de cliente.
Despliegue en IIS, Azure App Service, contenedores, Kubernetes, Linux services o plataformas internas según arquitectura.
Control de secretos mediante gestores adecuados, evitando `appsettings` productivos con credenciales en repositorio.
Aplicación de quality gates: tests, análisis estático, revisión de dependencias, seguridad, cobertura, auditoría y aprobación manual.
Preparación de estrategias de rollback, health checks, smoke tests y validaciones postdeploy.
Gestión de assets estáticos, caché, fingerprinting y versionado para evitar clientes con recursos obsoletos tras despliegue.
Automatización de migraciones, cambios de configuración y publicación de paquetes internos con revisión explícita.
Documentación del pipeline con propósito, owner, entornos, variables, secretos, aprobaciones y procedimiento de fallo.
Tema 24: Arquitectura limpia, modularidad y mantenibilidad en Blazor
Diseño de aplicaciones Blazor con separación clara entre UI, servicios de aplicación, dominio, infraestructura y clientes externos.
Aplicación de patrones como clean architecture, arquitectura por módulos, feature folders o vertical slices cuando encajan con el proyecto.
Evitación de componentes con lógica de negocio, consultas, reglas, permisos y renderizado mezclados en el mismo archivo.
Creación de servicios de caso de uso que encapsulan operaciones de negocio y simplifican la UI.
Organización por funcionalidades para equipos que trabajan en módulos independientes de una aplicación grande.
Uso de contratos internos para desacoplar componentes de APIs, persistencia o servicios externos.
Gestión de dependencias entre módulos para evitar que toda la aplicación se convierta en una capa compartida caótica.
Preparación de componentes testables, servicios reemplazables y lógica reutilizable.
Revisión de deuda técnica típica en Blazor: estado global descontrolado, componentes gigantes, interop disperso y CSS inconsistente.
Definición de una arquitectura base para proyectos Blazor empresariales mantenibles durante años.
Tema 25: Migración desde MVC, Razor Pages, Web Forms o SPA JavaScript
Evaluación de aplicaciones existentes para decidir si conviene migrar a Blazor, convivir parcialmente o mantener la tecnología actual.
Identificación de pantallas candidatas: formularios internos, paneles administrativos, dashboards, herramientas de gestión y módulos aislados.
Diseño de migración gradual desde MVC o Razor Pages reutilizando autenticación, servicios, validaciones, layouts o APIs existentes.
Planificación de transición desde Web Forms con especial atención a estado, eventos, controles, validación y arquitectura.
Migración desde SPA JavaScript cuando el equipo quiere reducir stack, compartir C# o simplificar mantenimiento en entornos .NET.
Creación de capas anticorrupción para convivir con sistemas legacy durante la transición.
Generación de pruebas de caracterización antes de reemplazar pantallas críticas.
Gestión de URLs, permisos, navegación, usuarios, sesiones y rutas durante la convivencia.
Comunicación de riesgos, fases, rollback y criterios de éxito a negocio y equipos técnicos.
Medición de avance por reducción de deuda, menor mantenimiento, mejor UX, menos bugs y mayor productividad del equipo.
Tema 26: Proyecto final integrador: aplicación Blazor empresarial lista para producción
Definición de una aplicación Blazor Web App realista para empresa, con módulos, usuarios, permisos, formularios, listados, APIs y requisitos de despliegue.
Selección razonada de render modes por pantalla o componente, justificando SSR, Interactive Server, WebAssembly o Auto según necesidad.
Diseño de arquitectura con componentes, servicios, clientes API, estado, validación, seguridad, librería compartida y documentación.
Implementación de autenticación, autorización, rutas protegidas, permisos por rol y control de acciones sensibles.
Construcción de formularios complejos con validación cliente-servidor, estados de guardado, mensajes de error y experiencia accesible.
Creación de listados con filtros, paginación, ordenación, acciones por fila, permisos y persistencia de parámetros en URL.
Integración con APIs, manejo de errores, loading states, cancelación, retry controlado y observabilidad básica.
Incorporación de tests de servicios, componentes, formularios, autorización y flujos críticos.
Preparación de pipeline CI/CD con build, tests, publicación, configuración por entorno, secrets y validaciones postdeploy.
Presentación final con arquitectura, decisiones técnicas, render modes, seguridad, testing, rendimiento, despliegue y plan de evolución.
Perfiles profesionales
Pensado para quienes deben dominar Blazor en su día a día
Desarrolladores backend .NET
Este curso encaja con desarrolladores que ya trabajan con C#, ASP.NET Core, APIs, servicios, Entity Framework Core o arquitectura backend y quieren ampliar su alcance hacia interfaces web modernas sin salir del ecosistema .NET. Aprenderán a construir aplicaciones Blazor bien estructuradas, conectadas con servicios internos, APIs seguras y lógica de negocio corporativa.
Desarrolladores full stack con experiencia en .NET
Los perfiles full stack podrán usar Blazor para crear experiencias web completas combinando componentes Razor, servicios, validación, estado, autenticación, APIs, CSS, JavaScript interop y despliegues. La formación les ayuda a tomar decisiones correctas sobre render modes, estructura de proyecto, reutilización de componentes y rendimiento.
Preguntas frecuentes
Resolvemos todas tus dudas sobre nuestra formación en Blazor
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á pensado para desarrolladores .NET, por lo que no parte de cero absoluto en programación. Sí empieza por fundamentos de Blazor, pero avanza rápido hacia arquitectura, seguridad, render modes, APIs, testing, rendimiento y despliegue.
Sí. El curso está actualizado a Blazor Web App en .NET 10. Microsoft documenta que la plantilla Blazor Web App permite combinar renderizado server-side, client-side, streaming rendering, enhanced navigation y render modes por componente.
Se trabajan Static SSR, Interactive Server, Interactive WebAssembly e Interactive Auto. Microsoft documenta que cada componente de una Blazor Web App adopta un render mode que determina dónde se renderiza y si es interactivo.
Sí. Blazor WebAssembly se trabaja tanto como render mode dentro de Blazor Web App como en sus implicaciones de carga, seguridad, llamadas API, rendimiento, dependencias, bundle y experiencia de usuario.
Sí. Se trabaja Interactive Server, circuitos, SignalR, memoria, reconexión, seguridad server-side y escalabilidad. Es clave para aplicaciones internas donde interesa mantener lógica sensible en servidor.
Sí. El curso cubre autenticación, autorización, roles, claims, políticas, Identity, Microsoft Entra ID, OIDC, rutas protegidas, permisos por recurso y seguridad de APIs. Blazor usa los mecanismos de autenticación existentes de ASP.NET Core, con diferencias según el hosting.
Sí. Se insiste en que el código client-side no debe ser la única barrera de seguridad. Microsoft advierte que la autorización ejecutada en cliente no puede considerarse confiable para aplicar reglas de acceso críticas.
Sí. Se incluye un bloque específico sobre Blazor Hybrid con .NET MAUI y BlazorWebView para reutilizar componentes Razor en aplicaciones desktop o mobile cuando tenga sentido.
Sí. El curso incluye testing de servicios, componentes, formularios, autorización, llamadas API, flujos críticos y pruebas end-to-end cuando el escenario lo exige.
Sí. Hay un bloque específico sobre migración desde MVC, Razor Pages, Web Forms o SPA JavaScript, con enfoque gradual, convivencia, pruebas de caracterización, reducción de deuda y control de riesgo.
Sí. Al tratarse de una formación corporativa en desarrollo .NET, aplicaciones web, seguridad, productividad, testing y competencias digitales, puede plantearse como formación bonificable hasta el 100% a través de FUNDAE, según el crédito disponible y cumpliendo los requisitos administrativos aplicables.
Está pensado para desarrolladores .NET, por lo que no parte de cero absoluto en programación. Sí empieza por fundamentos de Blazor, pero avanza rápido hacia arquitectura, seguridad, render modes, APIs, testing, rendimiento y despliegue.
Sí. El curso está actualizado a Blazor Web App en .NET 10. Microsoft documenta que la plantilla Blazor Web App permite combinar renderizado server-side, client-side, streaming rendering, enhanced navigation y render modes por componente.
Se trabajan Static SSR, Interactive Server, Interactive WebAssembly e Interactive Auto. Microsoft documenta que cada componente de una Blazor Web App adopta un render mode que determina dónde se renderiza y si es interactivo.
Sí. Blazor WebAssembly se trabaja tanto como render mode dentro de Blazor Web App como en sus implicaciones de carga, seguridad, llamadas API, rendimiento, dependencias, bundle y experiencia de usuario.
Sí. Se trabaja Interactive Server, circuitos, SignalR, memoria, reconexión, seguridad server-side y escalabilidad. Es clave para aplicaciones internas donde interesa mantener lógica sensible en servidor.
Sí. El curso cubre autenticación, autorización, roles, claims, políticas, Identity, Microsoft Entra ID, OIDC, rutas protegidas, permisos por recurso y seguridad de APIs. Blazor usa los mecanismos de autenticación existentes de ASP.NET Core, con diferencias según el hosting.
Sí. Se insiste en que el código client-side no debe ser la única barrera de seguridad. Microsoft advierte que la autorización ejecutada en cliente no puede considerarse confiable para aplicar reglas de acceso críticas.
Sí. Se incluye un bloque específico sobre Blazor Hybrid con .NET MAUI y BlazorWebView para reutilizar componentes Razor en aplicaciones desktop o mobile cuando tenga sentido.
Sí. El curso incluye testing de servicios, componentes, formularios, autorización, llamadas API, flujos críticos y pruebas end-to-end cuando el escenario lo exige.
Sí. Hay un bloque específico sobre migración desde MVC, Razor Pages, Web Forms o SPA JavaScript, con enfoque gradual, convivencia, pruebas de caracterización, reducción de deuda y control de riesgo.
Sí. Al tratarse de una formación corporativa en desarrollo .NET, aplicaciones web, seguridad, productividad, testing y competencias digitales, puede plantearse como formación bonificable hasta el 100% a través de FUNDAE, según el crédito disponible y cumpliendo los requisitos administrativos aplicables.
Diseñemos hoy el curso que tu empresa necesita
Cuéntanos tus objetivos de negocio y prepararemos una propuesta formativa bonificable totalmente ad hoc
evita el error habitual de crear componentes enormes y acoplados. Se trabajan servicios, estado, librerías Razor, arquitectura modular, testing y documentación para que la aplicación siga siendo mantenible a largo plazo.
2
Integra seguridad desde el diseño Blazor puede mezclar ejecución server-side y client-side, por lo que la seguridad debe plantearse bien. El curso trabaja autenticación, autorización, permisos por recurso, antiforgery, APIs seguras, datos sensibles y controles server-side.
3
Mejora la productividad en aplicaciones internas Portales administrativos, backoffices, dashboards y formularios empresariales suelen encajar muy bien con Blazor. El curso aporta patrones concretos para tablas, filtros, formularios, permisos, validaciones y flujos de gestión.
4
Prepara para producción, no solo para demos Se cubren rendimiento, observabilidad, testing, CI/CD, configuración por entorno, despliegue, soporte y diagnóstico. Esto permite pasar de prototipos a aplicaciones corporativas estables y operables.
5
Facilita modernización de aplicaciones .NET existentes Los equipos que vienen de MVC, Razor Pages, Web Forms o frontends separados pueden usar Blazor de forma gradual. El curso enseña a convivir con sistemas actuales, reducir deuda y migrar por módulos con menos riesgo.
Después de la formación en directo, los alumnos podrán acceder a ejercicios prácticos para aplicar lo trabajado en clase y consolidar el aprendizaje con actividades guiadas.
Acceso a las grabaciones
Los alumnos podrán revisar las sesiones grabadas para repasar conceptos clave, recuperar explicaciones concretas o reforzar aquellos contenidos que necesiten después de la clase en directo.
Recursos formativos
Materiales, sesiones grabadas y documentación de apoyo quedan centralizados en la plataforma para que el equipo pueda consultarlos durante y después de la formación.
Confirmación de asistencia
La plataforma permite registrar y confirmar la asistencia de los participantes, facilitando el seguimiento de la formación y la gestión documental necesaria para la bonificación FUNDAE.
Ejercicios prácticos
Después de la formación en directo, los alumnos podrán acceder a ejercicios prácticos para aplicar lo trabajado en clase y consolidar el aprendizaje con actividades guiadas.
Practica y mejora con nuestra plataforma
Una plataforma practica, con IA integrada y pensada para que mejores desarrollando. Se adapta a tu ritmo, te corrige al instante y te muestra tu progreso real.
Correccion magica
Feedback inteligente
Aprende de cada acierto y fallo con explicaciones claras
Los equipos que vienen de MVC, Razor Pages, Web Forms, aplicaciones internas antiguas o frontends separados podrán usar Blazor para modernizar interfaces sin reescribir todo desde cero. El curso trabaja migraciones graduales, convivencia con APIs existentes, reutilización de lógica y reducción de deuda técnica.
Tech leads y responsables técnicos .NET
Los perfiles con responsabilidad sobre arquitectura podrán definir patrones de componentes, estructura de carpetas, librerías Razor, estándares de formularios, seguridad, testing, observabilidad y despliegue. La formación les aporta criterio para evitar aplicaciones Blazor difíciles de mantener cuando crecen los equipos y funcionalidades.
Equipos de producto interno y aplicaciones corporativas
Los equipos que construyen portales internos, backoffice, dashboards, herramientas de gestión, intranets o aplicaciones administrativas podrán aplicar Blazor a escenarios reales de negocio. El curso pone foco en productividad, seguridad, mantenibilidad, formularios complejos, tablas, permisos y experiencia de usuario.
Desarrolladores interesados en Blazor Hybrid
Los perfiles que quieren reutilizar componentes Razor en escenarios desktop o mobile podrán entender cuándo tiene sentido Blazor Hybrid con .NET MAUI. Microsoft documenta que BlazorWebView permite hospedar una app Blazor dentro de una app .NET MAUI e integrar la UI web con capacidades de plataforma.