Introducción
En el artículo anterior de esta serie, analicé si Blazor WebAssembly está listo para producción corporativa comparándolo con Angular. La conclusión fue matizada: Blazor WASM es viable para escenarios corporativos internos, pero tiene trade-offs que deben evaluarse caso por caso. Hoy lo demostraré en la práctica construyendo un CRUD completo de productos con DataGrid paginado, formularios con validación, dialogs, notificaciones e inline editing — todo en C#, sin escribir una sola línea de JavaScript.
La biblioteca de componentes de UI que elegí es Radzen Blazor, una biblioteca open source (licencia MIT) con más de 70 componentes gratuitos. La razón principal: Radzen ofrece una experiencia visual madura para escenarios CRUD corporativos, con DataGrid, formularios, validación, dialogs y notificaciones listos para usar. El JavaScript que se ejecuta internamente (Radzen.Blazor.js) es de la propia biblioteca: el desarrollador nunca toca JS directamente.
Lo que voy a construir en este tutorial:
- API REST con Minimal API para Productos y Categorías (10 endpoints)
- Blazor WASM Standalone consumiendo la API vía
HttpClient - DataGrid paginado con búsqueda, ordenación y acciones por fila
- Formulario en dialog reutilizable para creación y edición
- Inline editing para Categorías (patrón alternativo al dialog)
- Eliminación con confirmación y notificaciones visuales
Todo el código está en el repositorio blog-zocateli-sample en GitHub. La idea es que lo clones, lo ejecutes y formes tu propia opinión. Este artículo es el 2.º de la serie “Frontend Moderno”: mi objetivo es demostrar que el ecosistema de componentes Blazor ya soporta escenarios reales de producción, con una experiencia de desarrollo familiar para quien viene de .NET.
ℹ️ Información: Radzen Blazor es open source (MIT) e incluye más de 70 componentes gratuitos.
Radzen.Blazor.jses JavaScript interno de la biblioteca: el desarrollador nunca escribe JavaScript directamente. La versión usada en este tutorial es la 10.2.0 con .NET 10.
Requisitos previos
Para seguir este tutorial, necesitarás:
- .NET 10 SDK (10.0.201 o superior) — descarga oficial
- IDE: VS Code con la extensión C# Dev Kit, o Visual Studio 2022 17.14+
- Conocimientos básicos de C# y REST APIs
- Terminal (PowerShell, bash o zsh)
Clona el repositorio con todo el código listo:
| |
Verifica que el SDK esté instalado:
| |
Salida esperada:
| |
💡 Consejo: Si usas VS Code con Dev Containers, el
.devcontainer/del repositorio ya tiene el .NET 10 SDK configurado. Basta con abrir el proyecto en el contenedor y todo estará listo.
Creando el Proyecto Blazor WASM Standalone
La plantilla blazorwasm de .NET crea una aplicación Blazor WebAssembly Standalone: una SPA que se ejecuta íntegramente en el navegador vía WebAssembly, sin un servidor ASP.NET Core que la aloje. A diferencia del modelo Hosted (que incluye un proyecto Server), el Standalone es una SPA pura que consume APIs externas vía HTTP, exactamente como una aplicación Angular o React.
Scaffolding del proyecto
| |
El primer comando crea el proyecto, el segundo lo añade a la solution y el tercero instala Radzen Blazor, la biblioteca de componentes de UI. El .csproj resultante queda compacto:
| |
Configurando Program.cs
Program.cs es el entry point de la SPA. Aquí configuro el HttpClient con la URL base de la API (vía appsettings.json), registro los servicios HTTP tipados y añado los componentes Radzen:
| |
La llamada AddRadzenComponents() registra automáticamente DialogService, NotificationService, TooltipService y ContextMenuService en el contenedor de DI. Sin ella, los dialogs y las notificaciones no funcionan.
Layout con Radzen
MainLayout.razor define la estructura visual de la aplicación: header con toggle de sidebar, navegación lateral con RadzenPanelMenu, área de contenido y footer:
| |
El componente <RadzenComponents /> al final es obligatorio: renderiza los contenedores para dialogs, notificaciones y tooltips. Sin él, DialogService.OpenAsync() y NotificationService.Notify() no muestran nada en pantalla.
⚠️ Atención:
<RadzenComponents />debe estar dentro del layout, no enApp.razor. Colocarlo fuera del layout puede causar problemas de renderizado con dialogs y notificaciones.
Para que el tema visual funcione, App.razor necesita incluir <RadzenTheme Theme="material" />:
| |
El tema material de Radzen incluye todo el estilo necesario: colores, tipografía, espaciado e íconos Material Design. No es necesario importar Bootstrap ni ningún otro framework CSS.
La API REST — Dominio Productos
Para que Blazor WASM consuma datos, creé un dominio Productos con Minimal API en el proyecto principal. Son 10 endpoints organizados en dos grupos:
| Verbo | Ruta | Descripción |
|---|---|---|
| GET | /api/produtos?pagina=1&tamanhoPagina=20&filtro= | Listar con paginación y filtro |
| GET | /api/produtos/{id} | Obtener por ID |
| POST | /api/produtos | Crear producto |
| PUT | /api/produtos/{id} | Actualizar producto |
| DELETE | /api/produtos/{id} | Eliminar producto |
| GET | /api/categorias | Listar todas |
| GET | /api/categorias/{id} | Obtener por ID |
| POST | /api/categorias | Crear categoría |
| PUT | /api/categorias/{id} | Actualizar categoría |
| DELETE | /api/categorias/{id} | Eliminar categoría |
ProdutoEndpoints.cs usa MapGroup para organizar las rutas y ProducesResponseType para documentarlas en Swagger:
| |
Los DTOs de request usan DataAnnotations para validación server-side, garantizando que la API valide los datos aunque el client-side sea eludido:
| |
La implementación del servicio usa ConcurrentDictionary como almacenamiento in-memory (una decisión de diseño para mantener el tutorial enfocado en Blazor WASM, sin dependencia de base de datos). El seed inicial incluye 8 categorías y más de 50 productos distribuidos entre ellas.
Configuración CORS
Como Blazor WASM Standalone se ejecuta en un puerto diferente al de la API (5200 vs 5101), es obligatorio configurar CORS en el Program.cs de la API:
| |
💡 Consejo: Configurar CORS es obligatorio para Blazor WASM Standalone. Sin configuración explícita, el navegador bloqueará las solicitudes cross-origin. En producción, sustituye los origins por dominios reales.
Para probar la API de forma aislada, ejecuta dotnet run --project src/BlogSamples y accede a http://localhost:5101/docs: Swagger muestra todos los endpoints de Productos y Categorías.
El diagrama siguiente muestra la arquitectura completa: Blazor WASM en el navegador se comunica con la API REST vía HttpClient (JSON) atravesando la barrera de CORS:

Servicios HTTP — Consumiendo la API
El patrón que uso para consumir la API es un servicio tipado con HttpClient inyectado vía primary constructor. Cada servicio encapsula las llamadas HTTP de un dominio específico, usando los métodos de extensión de System.Net.Http.Json: GetFromJsonAsync, PostAsJsonAsync y PutAsJsonAsync:
| |
Algunos puntos importantes sobre este patrón:
Uri.EscapeDataStringen el filtro previene la inyección de parámetros en la query string. Nunca concatenes strings directamente en URLs sin encoding.EnsureSuccessStatusCode()lanzaHttpRequestExceptionsi la API devuelve error (4xx, 5xx). En el componente Blazor, capturo esa excepción para mostrar una notificación de error al usuario.- Primary constructor (
HttpClient http) evita el boilerplate de campo + constructor. ElHttpClientlo resuelve el contenedor de DI con laBaseAddressconfigurada enProgram.cs.
CategoriaApiService sigue exactamente el mismo patrón, con los métodos ListarAsync, CriarAsync, AtualizarAsync y RemoverAsync.
En Angular, HttpClient con interceptors y operadores RxJS ofrece una ergonomía similar. En Blazor, la experiencia es equivalente: DelegatingHandler sirve como interceptor para autenticación, logging o retry. La diferencia principal es que Blazor usa el async/await nativo de C# en lugar del Observable de RxJS.
ℹ️ Información: Los models de Blazor WASM son clases (no records). Radzen Blazor usa two-way binding (
@bind-Value), que requiere setters mutables. Los records coninitno funcionan para edición en formularios Radzen.
DataGrid de Productos con Radzen
RadzenDataGrid es el componente central de este tutorial. Soporta paginación server-side, sorting, filtering, templates personalizados por columna e integración directa con el patrón LoadData: un callback que el grid llama cada vez que necesita datos nuevos (al cambiar de página, ordenar o filtrar).
Aquí está el Produtos.razor completo; explicaré cada parte:
| |
Detallo los puntos clave:
LoadData="@CarregarDados": el grid llama a este callback al inicializar, al cambiar de página y al ordenar. RecibeLoadDataArgsconSkip,Tope información de ordenación. Esta es la clave de la paginación server-side.Data+Count:Datarecibe la página actual de ítems;Countinforma el total de registros. El grid calcula el número de páginas automáticamente.FormatString="{0:C2}": formatea el precio como moneda. Blazor WASM usa la cultura configurada en el navegador, así que en pt-BR muestra “R$ 1.299,00”.Template: columnas personalizadas. UsoRadzenBadgepara mostrar el estado como badge verde/gris y botones de acción (Editar, Eliminar) con íconos Material Design.IsLoading: muestra un spinner mientras se llama a la API. Mejora significativamente la UX en conexiones lentas.
El bloque @code contiene la lógica:
| |
El método CarregarDados convierte Skip/Top (patrón de Radzen) a pagina/tamanhoPagina (patrón de mi API). Cuando el usuario escribe en el campo de búsqueda, OnFiltroChanged vuelve a la primera página con grid.FirstPage(true): el true fuerza la recarga que llama de nuevo a CarregarDados con el filtro actualizado.
⚠️ Atención: El evento
LoadDatadelRadzenDataGridse llama cada vez que el grid necesita datos: paging, sorting, filtering. No lo confundas con el binding directo deData, que es para datos client-side. Si usasDatacon una lista completa yAllowPaging, la paginación será client-side (todos los datos cargados de una vez). ConLoadData+Count, la paginación es server-side (solo se carga la página actual).
Formulario de Creación y Edición
ProdutoForm.razor es un componente reutilizable que sirve tanto para crear como para editar productos. La distinción la hace el Parameter ProdutoId: si es null, es creación; si tiene valor, es edición. El formulario se abre en un dialog modal vía DialogService.OpenAsync<ProdutoForm>().
| |
Destaco los puntos más importantes del formulario:
RadzenTemplateForm<CriarProdutoRequest>: encapsula todo el formulario con validación. El eventoSubmitsolo se dispara si todos los validators pasan.RadzenRequiredValidatoryRadzenNumericRangeValidator: validación client-side con feedback visual automático (bordes rojos, mensaje de error debajo del campo). La validación server-side vía DataAnnotations en la API es la segunda capa de protección.RadzenDropDown<int>para categorías:Datarecibe la lista,TextPropertyyValuePropertymapean las propiedades del DTO.AllowFiltering="true"habilita la búsqueda inline en el dropdown (útil cuando hay muchas categorías).RadzenSwitchcon label dinámico: muestra “Ativo” o “Inativo” según el estado del toggle.- Botón Cancelar con
ButtonType="ButtonType.Button": sin esto, el click en Cancelar dispara el submit del formulario.
El bloque @code contiene la lógica de inicialización y submit:
| |
El flujo completo es: el usuario hace clic en “Novo Produto” → DialogService.OpenAsync<ProdutoForm>() abre el dialog → el form carga las categorías y, si es edición, carga el producto → el usuario completa/edita → los validators verifican → OnSubmit llama a la API → DialogService.Close(true) cierra el dialog → el grid detecta resultado is true y llama a grid.Reload() → datos actualizados.
Para abrir el dialog desde Produtos.razor:
| |
El diccionario { "ProdutoId", produtoId } pasa el parámetro al componente ProdutoForm. DialogOptions controla el ancho del dialog y si se cierra al hacer clic fuera o al pulsar Escape.
📝 Ejemplo: Flujo de edición: haz clic en el botón “Editar” de un producto → el dialog se abre con el título “Editar Produto” → campos rellenados con los datos actuales → cambia el precio → haz clic en Salvar → notificación verde “Produto atualizado” → el grid recarga con el precio nuevo.
Eliminación con Confirmación y Notificaciones
Toda operación destructiva debe tener una etapa de confirmación. DialogService.Confirm() de Radzen renderiza un dialog nativo con botones personalizables:
| |
Las notificaciones de Radzen (NotificationService.Notify) aparecen como toasts en la esquina de la pantalla. Uso NotificationSeverity.Success con una duración de 4 segundos para operaciones exitosas y NotificationSeverity.Error con 6 segundos para errores: más tiempo para que el usuario lea el mensaje. El patrón try/catch con HttpRequestException es simple pero eficaz: si la API devuelve error (p. ej., producto no encontrado), el catch muestra feedback inmediato al usuario.
Gestión de Categorías — Inline Editing
Para demostrar un patrón alternativo al dialog, la pantalla de Categorías usa inline editing: el usuario edita directamente en el grid, sin abrir un modal. Este enfoque funciona bien para entidades simples con pocos campos.
| |
La diferencia principal está en EditMode="DataGridEditMode.Single": cuando el usuario hace clic en “Editar”, la fila entra en modo de edición; los campos de texto y el switch aparecen en lugar de los valores estáticos. Los botones cambian de “Editar/Eliminar” a “Guardar/Cancelar”.
La lógica de edición inline:
| |
El flujo para “Nueva Categoría” es: insertar un objeto vacío en la posición 0 de la lista → grid.EditRow() pone esa fila en modo de edición → el usuario la completa → SalvarLinha llama a grid.UpdateRow() → se dispara OnRowCreate (porque Id == 0) → se llama a la API → datos recargados.
Cuándo usar inline editing vs dialog:
| Escenario | Inline Editing | Dialog |
|---|---|---|
| Entidades simples (2-4 campos) | ✅ Ideal | Excesivo |
| Entidades complejas (5+ campos, dropdowns) | Confuso | ✅ Ideal |
| Campos con validación elaborada | Limitado | ✅ Más espacio visual |
| Edición rápida y frecuente | ✅ Menos clics | Más clics |
| UX móvil | ⚠️ Puede quedar apretado | ✅ Mejor en pantallas pequeñas |
Consejos y Buenas Prácticas
Centraliza las llamadas HTTP en servicios tipados: nunca inyectes
HttpClientdirectamente en el componente.razor. Eso viola la separación de responsabilidades y dificulta las pruebas. Servicios comoProdutoApiServiceencapsulan URLs, serialización y manejo de errores en un único lugar reutilizable.Usa DataAnnotations + validators Radzen para doble validación:
RadzenRequiredValidatoryRadzenNumericRangeValidatorvalidan en el cliente; las DataAnnotations en el DTO de request validan en el servidor. Si alguien elude la UI y llama directamente a la API, la validación server-side sigue protegiendo los datos.RadzenNotification para TODA acción: feedback visual consistente en éxito (“Produto criado”) y error (“Não foi possível salvar”). Define duraciones distintas: 4 segundos para éxito, 6+ para errores (el usuario necesita más tiempo para leer el mensaje de error).
Evento LoadData para paginación server-side: nunca cargues todos los datos en el cliente con una lista completa. Con
LoadData, solo se transfiere por la red la página actual. Para un catálogo con 10.000 productos, cargarlo todo en la memoria del navegador es inviable; con paginación server-side, cada request trae solo 20 registros.Componentiza formularios reutilizables:
ProdutoFormsirve para creación Y edición. La distinción es unParameternullable (int? ProdutoId). Este patrón elimina duplicación de código y garantiza consistencia entre los flujos de creación y edición.Configura
appsettings.jsonpara la URL de la API: nunca hagas hardcode de URLs. Elwwwroot/appsettings.jsonen Blazor WASM funciona como archivo de configuración por entorno. En producción, sustitúyelo porappsettings.Production.jsoncon la URL real de la API.Implementa el estado de carga en el DataGrid: la propiedad
IsLoadingdelRadzenDataGridmuestra un spinner mientras se llama a la API. Sin feedback visual, el usuario no sabe si la acción se disparó o si la aplicación se colgó. DefineisLoading = trueantes de la llamada yfalsedespués.Configura AOT + Trimming para producción: el bundle size de Blazor WASM es una preocupación real. Para producción, habilita la compilación AOT y el trimming en el
.csproj:1 2 3 4<PropertyGroup> <RunAOTCompilation>true</RunAOTCompilation> <PublishTrimmed>true</PublishTrimmed> </PropertyGroup>AOT compila el IL a WebAssembly nativo (ejecución más rápida), y el trimming elimina el código no utilizado (bundle más pequeño). El trade-off es un tiempo de build significativamente mayor.
Conclusión
En este tutorial construí un CRUD completo con Blazor WebAssembly .NET 10 y Radzen Blazor: DataGrid con paginación server-side y búsqueda, formularios con validación client-side y server-side, dialogs modales para creación y edición, inline editing para entidades simples, eliminación con confirmación y notificaciones visuales de feedback — todo en C#, sin que el desarrollador escriba una sola línea de JavaScript.
Radzen Blazor ofrece componentes visuales maduros para el escenario CRUD corporativo. RadzenDataGrid con LoadData resuelve la paginación server-side de forma elegante. Los validators (RadzenRequiredValidator, RadzenNumericRangeValidator) funcionan bien para validación básica. DialogService y NotificationService cubren el flujo completo de interacción con el usuario.
Pero es importante ser transparente sobre las limitaciones que encontré durante el desarrollo:
Radzen.Blazor.jses necesario: a pesar del eslogan “cero JavaScript”, la biblioteca depende de JS interno para renderizar componentes complejos. No es JavaScript escrito por el desarrollador, pero es JS ejecutándose en el navegador.- El two-way binding requiere clases, no records: el
@bind-Valuede Radzen necesita setters mutables. Los records coninitno funcionan para formularios de edición. Esto obliga a usar clases para los DTOs en Blazor WASM. - El bundle size sigue siendo significativo: el runtime de .NET + Radzen + la aplicación resultan en una descarga inicial considerable. AOT y trimming ayudan, pero no lo resuelven por completo.
Como analicé en el artículo anterior, Blazor WASM es viable para contextos corporativos, y este tutorial demuestra que el ecosistema de componentes soporta escenarios reales. La elección entre Blazor WASM y frameworks JavaScript como Angular o React depende del perfil del equipo, de los requisitos de SEO/SSR y de la tolerancia al bundle size, como expliqué en el comparativo.
Clona el repositorio, ejecuta la API y Blazor WASM, y forma tu propia opinión. El código completo está en frontend/blazor-wasm/ y src/BlogSamples/Produtos/.
Lee También
- ¿Tu Próximo Frontend Será C#? La Verdad Sobre Blazor WASM — comparativo teórico Blazor vs Angular (1.er artículo de la serie “Frontend Moderno”)
- Diseño de API REST: Verbos HTTP y Parameter Binding — la estructura de Minimal API que Blazor WASM consume en este tutorial
- Log Sin Contexto es Ruido: Logging Estructurado en .NET 8 — ecosistema .NET maduro con logging, métricas y tracing
- Autenticación y Autorización: JWT, OAuth2 y OpenID Connect — próximo paso: proteger la SPA Blazor con Entra ID
Referencias
- Blazor WebAssembly — Documentación oficial — Microsoft Learn, referencia completa sobre Blazor
- ASP.NET Core 10.0 Release Notes — novedades de .NET 10 para la web
- Radzen Blazor Components — Get Started — configuración y guía inicial de la biblioteca
- Radzen Blazor — GitHub — código fuente (MIT) con ejemplos e issues
- Radzen DataGrid — documentación y demos interactivas del componente central
- blog-zocateli-sample — GitHub — repositorio con todo el código de este artículo
- WebAssembly — especificación oficial del estándar W3C
- Blazor WASM Standalone Deployment — guía de despliegue para producción

Al comentar, aceptas nuestra Política de Privacidad, Términos de Uso, Política de Eliminación de Datos.