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.js es 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:

1
2
git clone https://github.com/lzocateli/blog-zocateli-sample.git
cd blog-zocateli-sample

Verifica que el SDK esté instalado:

1
dotnet --version

Salida esperada:

1
10.0.201

💡 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

1
2
3
dotnet new blazorwasm --name BlogSamples.BlazorWasm --output frontend/blazor-wasm --framework net10.0
dotnet sln add frontend/blazor-wasm
dotnet add frontend/blazor-wasm package Radzen.Blazor

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:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
<Project Sdk="Microsoft.NET.Sdk.BlazorWebAssembly">
  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly" Version="10.0.5" />
    <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly.DevServer" Version="10.0.5" PrivateAssets="all" />
    <PackageReference Include="Radzen.Blazor" Version="10.2.0" />
  </ItemGroup>
</Project>

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:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
using Microsoft.AspNetCore.Components.Web;
using Microsoft.AspNetCore.Components.WebAssembly.Hosting;
using BlogSamples.BlazorWasm;
using BlogSamples.BlazorWasm.Services;
using Radzen;

var builder = WebAssemblyHostBuilder.CreateDefault(args);
builder.RootComponents.Add<App>("#app");
builder.RootComponents.Add<HeadOutlet>("head::after");

// Configurar HttpClient con la URL base de la API
var apiBaseUrl = builder.Configuration["ApiBaseUrl"] ?? "http://localhost:5101";
builder.Services.AddScoped(sp => new HttpClient { BaseAddress = new Uri(apiBaseUrl) });

// Servicios HTTP tipados
builder.Services.AddScoped<ProdutoApiService>();
builder.Services.AddScoped<CategoriaApiService>();

// Componentes Radzen (DialogService, NotificationService, etc.)
builder.Services.AddRadzenComponents();

await builder.Build().RunAsync();

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:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
@inherits LayoutComponentBase

<RadzenLayout>
    <RadzenHeader>
        <RadzenStack Orientation="Orientation.Horizontal" AlignItems="AlignItems.Center"
                     Gap="0.5rem" class="rz-p-2">
            <RadzenSidebarToggle Click="@(() => sidebarExpanded = !sidebarExpanded)" />
            <RadzenText Text="Blog Samples — Blazor WASM" TextStyle="TextStyle.H5"
                        class="rz-m-0" />
        </RadzenStack>
    </RadzenHeader>

    <RadzenSidebar @bind-Expanded="@sidebarExpanded">
        <RadzenPanelMenu>
            <RadzenPanelMenuItem Text="Dashboard" Icon="dashboard" Path="/" />
            <RadzenPanelMenuItem Text="Produtos" Icon="inventory_2" Path="/produtos" />
            <RadzenPanelMenuItem Text="Categorias" Icon="category" Path="/categorias" />
        </RadzenPanelMenu>
    </RadzenSidebar>

    <RadzenBody>
        <div class="rz-p-4">
            @Body
        </div>
    </RadzenBody>

    <RadzenFooter>
        <RadzenText Text="© 2026 Blog Samples — zocate.li" TextStyle="TextStyle.Caption"
                    class="rz-p-2" />
    </RadzenFooter>
</RadzenLayout>

<RadzenComponents />

@code {
    bool sidebarExpanded = true;
}

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 en App.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" />:

1
2
3
4
<RadzenTheme Theme="material" />
<Router AppAssembly="typeof(Program).Assembly">
    <!-- ... -->
</Router>

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:

VerboRutaDescripción
GET/api/produtos?pagina=1&tamanhoPagina=20&filtro=Listar con paginación y filtro
GET/api/produtos/{id}Obtener por ID
POST/api/produtosCrear producto
PUT/api/produtos/{id}Actualizar producto
DELETE/api/produtos/{id}Eliminar producto
GET/api/categoriasListar todas
GET/api/categorias/{id}Obtener por ID
POST/api/categoriasCrear 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:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public static class ProdutoEndpoints
{
    public static void MapProdutoEndpoints(this IEndpointRouteBuilder app)
    {
        var produtos = app.MapGroup("/api/produtos")
            .WithTags("Produtos");

        produtos.MapGet("/", async (
            IProdutoService service,
            int pagina = 1,
            int tamanhoPagina = 20,
            string? filtro = null) =>
        {
            var resultado = await service.ListarProdutosAsync(pagina, tamanhoPagina, filtro);
            return Results.Ok(resultado);
        })
        .WithName("ListarProdutos")
        .Produces<PagedResult<ProdutoDto>>();

        produtos.MapPost("/", async (CriarProdutoRequest request, IProdutoService service) =>
        {
            var produto = await service.CriarProdutoAsync(request);
            return Results.CreatedAtRoute("ObterProduto", new { id = produto.Id }, produto);
        })
        .WithName("CriarProduto")
        .Produces<ProdutoDto>(201)
        .ProducesValidationProblem();

        // ... PUT, DELETE y los endpoints de Categorias siguen el mismo patrón
    }
}

Los DTOs de request usan DataAnnotations para validación server-side, garantizando que la API valide los datos aunque el client-side sea eludido:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
public record CriarProdutoRequest
{
    [Required(ErrorMessage = "Nome é obrigatório")]
    [StringLength(200, MinimumLength = 3)]
    public string Nome { get; init; } = string.Empty;

    public string? Descricao { get; init; }

    [Range(0.01, double.MaxValue, ErrorMessage = "Preço deve ser maior que zero")]
    public decimal Preco { get; init; }

    [Range(0, int.MaxValue)]
    public int QuantidadeEstoque { get; init; }

    [Range(1, int.MaxValue, ErrorMessage = "Selecione uma categoria")]
    public int CategoriaId { get; init; }

    public bool Ativo { get; init; } = true;
}

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:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
builder.Services.AddCors(options =>
{
    options.AddPolicy("BlazorWasm", policy =>
    {
        policy.WithOrigins("http://localhost:5200", "https://localhost:7200")
              .AllowAnyHeader()
              .AllowAnyMethod();
    });
});

// En el pipeline:
app.UseCors("BlazorWasm");

💡 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:

Diagrama de arquitectura mostrando Blazor WASM comunicándose con una API REST vía HttpClient y 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:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
using System.Net.Http.Json;
using BlogSamples.BlazorWasm.Models;

namespace BlogSamples.BlazorWasm.Services;

public class ProdutoApiService(HttpClient http)
{
    public async Task<PagedResult<ProdutoDto>> ListarAsync(
        int pagina = 1, int tamanhoPagina = 20, string? filtro = null)
    {
        var url = $"api/produtos?pagina={pagina}&tamanhoPagina={tamanhoPagina}";
        if (!string.IsNullOrWhiteSpace(filtro))
            url += $"&filtro={Uri.EscapeDataString(filtro)}";

        return await http.GetFromJsonAsync<PagedResult<ProdutoDto>>(url)
            ?? new PagedResult<ProdutoDto>();
    }

    public async Task<ProdutoDto?> ObterPorIdAsync(int id)
        => await http.GetFromJsonAsync<ProdutoDto>($"api/produtos/{id}");

    public async Task<ProdutoDto?> CriarAsync(CriarProdutoRequest request)
    {
        var response = await http.PostAsJsonAsync("api/produtos", request);
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadFromJsonAsync<ProdutoDto>();
    }

    public async Task<ProdutoDto?> AtualizarAsync(int id, AtualizarProdutoRequest request)
    {
        var response = await http.PutAsJsonAsync($"api/produtos/{id}", request);
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadFromJsonAsync<ProdutoDto>();
    }

    public async Task RemoverAsync(int id)
    {
        var response = await http.DeleteAsync($"api/produtos/{id}");
        response.EnsureSuccessStatusCode();
    }
}

Algunos puntos importantes sobre este patrón:

  • Uri.EscapeDataString en el filtro previene la inyección de parámetros en la query string. Nunca concatenes strings directamente en URLs sin encoding.
  • EnsureSuccessStatusCode() lanza HttpRequestException si 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. El HttpClient lo resuelve el contenedor de DI con la BaseAddress configurada en Program.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 con init no 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:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
@page "/produtos"

<PageTitle>Produtos — Blog Samples</PageTitle>

<RadzenText TextStyle="TextStyle.H3" class="rz-mb-4">Produtos</RadzenText>

<RadzenStack Orientation="Orientation.Horizontal" AlignItems="AlignItems.Center"
             Gap="1rem" class="rz-mb-4">
    <RadzenTextBox Placeholder="Buscar produtos..." @bind-Value="filtro"
                   Change="@OnFiltroChanged" Style="width: 300px;" />
    <RadzenButton Text="Novo Produto" Icon="add" ButtonStyle="ButtonStyle.Primary"
                  Click="@(() => AbrirFormulario(null))" />
</RadzenStack>

<RadzenDataGrid @ref="grid" TItem="ProdutoDto"
                Data="@produtos" Count="@totalRegistros"
                LoadData="@CarregarDados"
                AllowPaging="true" PageSize="20"
                AllowSorting="true"
                PagerHorizontalAlign="HorizontalAlign.Center"
                IsLoading="@isLoading"
                Style="width: 100%;">
    <Columns>
        <RadzenDataGridColumn TItem="ProdutoDto" Property="Id" Title="ID"
                              Width="70px" TextAlign="TextAlign.Center" Sortable="false" />

        <RadzenDataGridColumn TItem="ProdutoDto" Property="Nome" Title="Nome"
                              MinWidth="200px" />

        <RadzenDataGridColumn TItem="ProdutoDto" Property="CategoriaNome" Title="Categoria"
                              Width="150px" />

        <RadzenDataGridColumn TItem="ProdutoDto" Property="Preco" Title="Preço"
                              Width="130px" TextAlign="TextAlign.End"
                              FormatString="{0:C2}" />

        <RadzenDataGridColumn TItem="ProdutoDto" Property="QuantidadeEstoque" Title="Estoque"
                              Width="100px" TextAlign="TextAlign.Center" />

        <RadzenDataGridColumn TItem="ProdutoDto" Property="Ativo" Title="Status"
                              Width="100px" TextAlign="TextAlign.Center" Sortable="false">
            <Template Context="produto">
                <RadzenBadge BadgeStyle="@(produto.Ativo ? BadgeStyle.Success : BadgeStyle.Light)"
                             Text="@(produto.Ativo ? "Ativo" : "Inativo")" />
            </Template>
        </RadzenDataGridColumn>

        <RadzenDataGridColumn TItem="ProdutoDto" Title="Ações" Width="140px"
                              TextAlign="TextAlign.Center" Sortable="false">
            <Template Context="produto">
                <RadzenButton Icon="edit" ButtonStyle="ButtonStyle.Light"
                              Size="ButtonSize.Small"
                              Click="@(() => AbrirFormulario(produto.Id))"
                              class="rz-mr-1" />
                <RadzenButton Icon="delete" ButtonStyle="ButtonStyle.Danger"
                              Size="ButtonSize.Small"
                              Click="@(() => ConfirmarExclusao(produto))" />
            </Template>
        </RadzenDataGridColumn>
    </Columns>
</RadzenDataGrid>

Detallo los puntos clave:

  • LoadData="@CarregarDados": el grid llama a este callback al inicializar, al cambiar de página y al ordenar. Recibe LoadDataArgs con Skip, Top e información de ordenación. Esta es la clave de la paginación server-side.
  • Data + Count: Data recibe la página actual de ítems; Count informa 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. Uso RadzenBadge para 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:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
@code {
    RadzenDataGrid<ProdutoDto> grid = default!;
    IEnumerable<ProdutoDto> produtos = [];
    int totalRegistros;
    string? filtro;
    bool isLoading;

    [Inject] ProdutoApiService ProdutoService { get; set; } = default!;
    [Inject] DialogService DialogService { get; set; } = default!;
    [Inject] NotificationService NotificationService { get; set; } = default!;

    async Task CarregarDados(LoadDataArgs args)
    {
        isLoading = true;

        var pagina = (args.Skip ?? 0) / (args.Top ?? 20) + 1;
        var tamanhoPagina = args.Top ?? 20;

        var resultado = await ProdutoService.ListarAsync(pagina, tamanhoPagina, filtro);

        produtos = resultado.Itens;
        totalRegistros = resultado.TotalRegistros;

        isLoading = false;
    }

    async Task OnFiltroChanged()
    {
        await grid.FirstPage(true);
    }
}

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 LoadData del RadzenDataGrid se llama cada vez que el grid necesita datos: paging, sorting, filtering. No lo confundas con el binding directo de Data, que es para datos client-side. Si usas Data con una lista completa y AllowPaging, la paginación será client-side (todos los datos cargados de una vez). Con LoadData + 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>().

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
<RadzenTemplateForm TItem="CriarProdutoRequest" Data="@model" Submit="@OnSubmit">
    <RadzenStack Gap="1rem">
        <RadzenFormField Text="Nome" Variant="Variant.Outlined">
            <ChildContent>
                <RadzenTextBox @bind-Value="model.Nome" MaxLength="200" />
            </ChildContent>
            <Helper>
                <RadzenRequiredValidator Component="Nome"
                                         Text="Nome é obrigatório" />
            </Helper>
        </RadzenFormField>

        <RadzenFormField Text="Descrição" Variant="Variant.Outlined">
            <ChildContent>
                <RadzenTextArea @bind-Value="model.Descricao" Rows="3" />
            </ChildContent>
        </RadzenFormField>

        <RadzenRow Gap="1rem">
            <RadzenColumn Size="6">
                <RadzenFormField Text="Preço (R$)" Variant="Variant.Outlined"
                                Style="width: 100%;">
                    <ChildContent>
                        <RadzenNumeric TValue="decimal" @bind-Value="model.Preco"
                                       Min="0.01m" Format="N2" />
                    </ChildContent>
                    <Helper>
                        <RadzenNumericRangeValidator Component="Preco" Min="0.01"
                                                     Text="Preço deve ser maior que zero" />
                    </Helper>
                </RadzenFormField>
            </RadzenColumn>
            <RadzenColumn Size="6">
                <RadzenFormField Text="Estoque" Variant="Variant.Outlined"
                                Style="width: 100%;">
                    <ChildContent>
                        <RadzenNumeric TValue="int" @bind-Value="model.QuantidadeEstoque"
                                       Min="0" />
                    </ChildContent>
                </RadzenFormField>
            </RadzenColumn>
        </RadzenRow>

        <RadzenFormField Text="Categoria" Variant="Variant.Outlined">
            <ChildContent>
                <RadzenDropDown TValue="int" @bind-Value="model.CategoriaId"
                                Data="@categorias" TextProperty="Nome"
                                ValueProperty="Id"
                                Placeholder="Selecione uma categoria..."
                                AllowFiltering="true" />
            </ChildContent>
            <Helper>
                <RadzenRequiredValidator Component="CategoriaId"
                                         Text="Selecione uma categoria"
                                         DefaultValue="0" />
            </Helper>
        </RadzenFormField>

        <RadzenStack Orientation="Orientation.Horizontal" AlignItems="AlignItems.Center"
                     Gap="0.5rem">
            <RadzenSwitch @bind-Value="model.Ativo" />
            <RadzenText Text="@(model.Ativo ? "Ativo" : "Inativo")" />
        </RadzenStack>

        <RadzenStack Orientation="Orientation.Horizontal"
                     JustifyContent="JustifyContent.End" Gap="0.5rem">
            <RadzenButton Text="Cancelar" ButtonStyle="ButtonStyle.Light"
                          Click="@(() => DialogService.Close(false))"
                          ButtonType="ButtonType.Button" />
            <RadzenButton Text="Salvar" ButtonStyle="ButtonStyle.Primary"
                          ButtonType="ButtonType.Submit" Icon="save" />
        </RadzenStack>
    </RadzenStack>
</RadzenTemplateForm>

Destaco los puntos más importantes del formulario:

  • RadzenTemplateForm<CriarProdutoRequest>: encapsula todo el formulario con validación. El evento Submit solo se dispara si todos los validators pasan.
  • RadzenRequiredValidator y RadzenNumericRangeValidator: 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: Data recibe la lista, TextProperty y ValueProperty mapean las propiedades del DTO. AllowFiltering="true" habilita la búsqueda inline en el dropdown (útil cuando hay muchas categorías).
  • RadzenSwitch con 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:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
@code {
    [Parameter] public int? ProdutoId { get; set; }

    [Inject] ProdutoApiService ProdutoService { get; set; } = default!;
    [Inject] CategoriaApiService CategoriaService { get; set; } = default!;
    [Inject] DialogService DialogService { get; set; } = default!;
    [Inject] NotificationService NotificationService { get; set; } = default!;

    CriarProdutoRequest model = new();
    IReadOnlyList<CategoriaDto> categorias = [];

    protected override async Task OnInitializedAsync()
    {
        categorias = await CategoriaService.ListarAsync();

        if (ProdutoId.HasValue)
        {
            var produto = await ProdutoService.ObterPorIdAsync(ProdutoId.Value);
            if (produto is not null)
            {
                model = new CriarProdutoRequest
                {
                    Nome = produto.Nome,
                    Descricao = produto.Descricao,
                    Preco = produto.Preco,
                    QuantidadeEstoque = produto.QuantidadeEstoque,
                    CategoriaId = produto.CategoriaId,
                    Ativo = produto.Ativo
                };
            }
        }
    }

    async Task OnSubmit()
    {
        try
        {
            if (ProdutoId.HasValue)
            {
                var request = new AtualizarProdutoRequest
                {
                    Nome = model.Nome,
                    Descricao = model.Descricao,
                    Preco = model.Preco,
                    QuantidadeEstoque = model.QuantidadeEstoque,
                    CategoriaId = model.CategoriaId,
                    Ativo = model.Ativo
                };
                await ProdutoService.AtualizarAsync(ProdutoId.Value, request);
            }
            else
            {
                await ProdutoService.CriarAsync(model);
            }

            DialogService.Close(true);
        }
        catch (HttpRequestException)
        {
            NotificationService.Notify(new NotificationMessage
            {
                Severity = NotificationSeverity.Error,
                Summary = "Erro ao salvar",
                Detail = "Não foi possível salvar o produto.",
                Duration = 6000
            });
        }
    }
}

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:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
async Task AbrirFormulario(int? produtoId)
{
    var titulo = produtoId.HasValue ? "Editar Produto" : "Novo Produto";

    var resultado = await DialogService.OpenAsync<ProdutoForm>(titulo,
        new Dictionary<string, object?> { { "ProdutoId", produtoId } },
        new DialogOptions
        {
            Width = "600px",
            CloseDialogOnOverlayClick = false,
            CloseDialogOnEsc = true
        });

    if (resultado is true)
    {
        await grid.Reload();
    }
}

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:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
async Task ConfirmarExclusao(ProdutoDto produto)
{
    var confirmado = await DialogService.Confirm(
        $"Deseja excluir o produto \"{produto.Nome}\"?",
        "Confirmar Exclusão",
        new ConfirmOptions
        {
            OkButtonText = "Excluir",
            CancelButtonText = "Cancelar"
        });

    if (confirmado == true)
    {
        try
        {
            await ProdutoService.RemoverAsync(produto.Id);
            NotificationService.Notify(new NotificationMessage
            {
                Severity = NotificationSeverity.Success,
                Summary = "Produto excluído",
                Detail = $"\"{produto.Nome}\" foi removido com sucesso.",
                Duration = 4000
            });
            await grid.Reload();
        }
        catch (HttpRequestException)
        {
            NotificationService.Notify(new NotificationMessage
            {
                Severity = NotificationSeverity.Error,
                Summary = "Erro ao excluir",
                Detail = "Não foi possível excluir o produto. Tente novamente.",
                Duration = 6000
            });
        }
    }
}

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.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
@page "/categorias"

<RadzenDataGrid @ref="grid" TItem="CategoriaDto"
                Data="@categorias" AllowSorting="true"
                EditMode="DataGridEditMode.Single"
                RowUpdate="@OnRowUpdate" RowCreate="@OnRowCreate"
                Style="width: 100%;">
    <Columns>
        <RadzenDataGridColumn TItem="CategoriaDto" Property="Id" Title="ID"
                              Width="70px" TextAlign="TextAlign.Center" />

        <RadzenDataGridColumn TItem="CategoriaDto" Property="Nome" Title="Nome"
                              MinWidth="200px">
            <EditTemplate Context="cat">
                <RadzenTextBox @bind-Value="cat.Nome" Style="width: 100%;" />
            </EditTemplate>
        </RadzenDataGridColumn>

        <RadzenDataGridColumn TItem="CategoriaDto" Property="Descricao"
                              Title="Descrição" MinWidth="250px">
            <EditTemplate Context="cat">
                <RadzenTextBox @bind-Value="cat.Descricao" Style="width: 100%;" />
            </EditTemplate>
        </RadzenDataGridColumn>

        <RadzenDataGridColumn TItem="CategoriaDto" Property="Ativo" Title="Status"
                              Width="100px" TextAlign="TextAlign.Center">
            <Template Context="cat">
                <RadzenBadge BadgeStyle="@(cat.Ativo ? BadgeStyle.Success : BadgeStyle.Light)"
                             Text="@(cat.Ativo ? "Ativo" : "Inativo")" />
            </Template>
            <EditTemplate Context="cat">
                <RadzenSwitch @bind-Value="cat.Ativo" />
            </EditTemplate>
        </RadzenDataGridColumn>

        <RadzenDataGridColumn TItem="CategoriaDto" Title="Ações" Width="180px"
                              TextAlign="TextAlign.Center" Sortable="false">
            <Template Context="cat">
                <RadzenButton Icon="edit" ButtonStyle="ButtonStyle.Light"
                              Size="ButtonSize.Small"
                              Click="@(() => EditarLinha(cat))" class="rz-mr-1" />
                <RadzenButton Icon="delete" ButtonStyle="ButtonStyle.Danger"
                              Size="ButtonSize.Small"
                              Click="@(() => ConfirmarExclusao(cat))" />
            </Template>
            <EditTemplate Context="cat">
                <RadzenButton Icon="check" ButtonStyle="ButtonStyle.Success"
                              Size="ButtonSize.Small"
                              Click="@(() => SalvarLinha(cat))" class="rz-mr-1" />
                <RadzenButton Icon="close" ButtonStyle="ButtonStyle.Light"
                              Size="ButtonSize.Small"
                              Click="@CancelarEdicao" />
            </EditTemplate>
        </RadzenDataGridColumn>
    </Columns>
</RadzenDataGrid>

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:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
@code {
    RadzenDataGrid<CategoriaDto> grid = default!;
    IList<CategoriaDto> categorias = [];
    CategoriaDto? categoriaEditando;

    async Task InserirNova()
    {
        var nova = new CategoriaDto { Ativo = true };
        categorias.Insert(0, nova);
        categoriaEditando = nova;
        await grid.EditRow(nova);
    }

    async Task EditarLinha(CategoriaDto cat)
    {
        categoriaEditando = cat;
        await grid.EditRow(cat);
    }

    async Task SalvarLinha(CategoriaDto cat)
    {
        await grid.UpdateRow(cat);
    }

    async Task OnRowUpdate(CategoriaDto cat)
    {
        var request = new AtualizarCategoriaRequest
        {
            Nome = cat.Nome,
            Descricao = cat.Descricao,
            Ativo = cat.Ativo
        };
        await CategoriaService.AtualizarAsync(cat.Id, request);
        categoriaEditando = null;
        await CarregarDados();
    }

    async Task OnRowCreate(CategoriaDto cat)
    {
        var request = new CriarCategoriaRequest
        {
            Nome = cat.Nome,
            Descricao = cat.Descricao,
            Ativo = cat.Ativo
        };
        await CategoriaService.CriarAsync(request);
        categoriaEditando = null;
        await CarregarDados();
    }
}

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:

EscenarioInline EditingDialog
Entidades simples (2-4 campos)✅ IdealExcesivo
Entidades complejas (5+ campos, dropdowns)Confuso✅ Ideal
Campos con validación elaboradaLimitado✅ Más espacio visual
Edición rápida y frecuente✅ Menos clicsMás clics
UX móvil⚠️ Puede quedar apretado✅ Mejor en pantallas pequeñas

Consejos y Buenas Prácticas

  1. Centraliza las llamadas HTTP en servicios tipados: nunca inyectes HttpClient directamente en el componente .razor. Eso viola la separación de responsabilidades y dificulta las pruebas. Servicios como ProdutoApiService encapsulan URLs, serialización y manejo de errores en un único lugar reutilizable.

  2. Usa DataAnnotations + validators Radzen para doble validación: RadzenRequiredValidator y RadzenNumericRangeValidator validan 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.

  3. 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).

  4. 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.

  5. Componentiza formularios reutilizables: ProdutoForm sirve para creación Y edición. La distinción es un Parameter nullable (int? ProdutoId). Este patrón elimina duplicación de código y garantiza consistencia entre los flujos de creación y edición.

  6. Configura appsettings.json para la URL de la API: nunca hagas hardcode de URLs. El wwwroot/appsettings.json en Blazor WASM funciona como archivo de configuración por entorno. En producción, sustitúyelo por appsettings.Production.json con la URL real de la API.

  7. Implementa el estado de carga en el DataGrid: la propiedad IsLoading del RadzenDataGrid muestra 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ó. Define isLoading = true antes de la llamada y false después.

  8. 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.js es 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-Value de Radzen necesita setters mutables. Los records con init no 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


Referencias