Nota:
El acceso a esta página requiere autorización. Puede intentar iniciar sesión o cambiar directorios.
El acceso a esta página requiere autorización. Puede intentar cambiar los directorios.
Note
Esta no es la versión más reciente de este artículo. Para obtener la versión actual, consulte la versión .NET 11 de este artículo.
Warning
Esta versión de ASP.NET Core ya no se admite. Para obtener más información, consulte la Política de soporte de .NET y .NET Core. Para la versión actual, consulte la versión de .NET 10 de este artículo.
En este artículo se muestran los componentes del validador reutilizable y la validación remota. Para las API comunes de validación de formularios, incluidas las anotaciones de datos, la validación directaEditContext, la visualización de mensajes, el estilo, el estado y el comportamiento de envío, consulte ASP.NET Core Blazor validación de formularios.
Para conocer las reglas de validación basadas en modelos compartidas por Blazor y las API mínimas, consulte Validación en ASP.NET Core.
Para la validación del explorador en la representación estática del lado servidor (SSR estático), consulte ASP.NET Core Blazor validación de formularios del lado cliente en SSR estático.
Compilación de un componente de validador
Un componente validador encapsula la validación que utiliza EditContext y ValidationMessageStore de un formulario. Esto resulta útil cuando varios formularios usan el mismo comportamiento de validación o cuando llegan errores de un servicio en lugar de de atributos de validación en el modelo.
Componente:
- Recibe el formulario
EditContextcomo un parámetro en cascada. - Crea un repositorio de mensajes para almacenar sus errores.
- Borra los errores de formulario obsoletos cuando se solicita la validación.
- Borra los errores obsoletos de un campo cuando cambia el campo.
- Expone métodos para mostrar y borrar errores.
- Cancela la suscripción de sus controladores de eventos al ser eliminado.
CustomValidation.razor:
@implements IDisposable
@code {
[CascadingParameter]
private EditContext? CurrentEditContext { get; set; }
private ValidationMessageStore messages = default!;
protected override void OnInitialized()
{
if (CurrentEditContext is null)
{
throw new InvalidOperationException(
"CustomValidation requires a cascading EditContext.");
}
messages = new ValidationMessageStore(CurrentEditContext);
CurrentEditContext.OnValidationRequested +=
HandleValidationRequested;
CurrentEditContext.OnFieldChanged += HandleFieldChanged;
}
public void DisplayErrors(IDictionary<string, string[]> errors)
{
foreach (var error in errors)
{
messages.Add(
CurrentEditContext!.Field(error.Key),
error.Value);
}
CurrentEditContext!.NotifyValidationStateChanged();
}
public void ClearErrors()
{
messages.Clear();
CurrentEditContext!.NotifyValidationStateChanged();
}
private void HandleValidationRequested(
object? sender, ValidationRequestedEventArgs e) =>
ClearErrors();
private void HandleFieldChanged(
object? sender, FieldChangedEventArgs e)
{
messages.Clear(e.FieldIdentifier);
CurrentEditContext!.NotifyValidationStateChanged();
}
public void Dispose()
{
if (CurrentEditContext is not null)
{
CurrentEditContext.OnValidationRequested -=
HandleValidationRequested;
CurrentEditContext.OnFieldChanged -= HandleFieldChanged;
}
}
}
Coloque el componente dentro de un EditForm y capture una referencia al componente cuando el formulario o un servicio deban mostrar errores:
<EditForm Model="Model" OnValidSubmit="Submit">
<DataAnnotationsValidator />
<CustomValidation @ref="customValidation" />
<ValidationSummary />
...
</EditForm>
@code {
private CustomValidation? customValidation;
}
El componente se puede usar junto con DataAnnotationsValidator. Cada validador tiene su propio almacén de mensajes asociado al mismo EditContext, y y ValidationSummaryValidationMessage muestran mensajes de ambos validadores.
Para implementar una regla de negocios dentro del componente de validador en lugar de aceptar errores externos, ejecute la regla desde HandleValidationRequested o HandleFieldChanged y agregue sus mensajes a messages. Para obtener un ejemplo más pequeño que realice esto directamente en un componente de formulario, consulte ASP.NET Core Blazor validación de formularios.
Agregar validación asincrónica
El mismo patrón de componente admite el trabajo asincrónico:
- En un controlador
OnValidationRequested, llame ae.AddAsyncValidatorpara registrar trabajo a nivel de formulario.EditFormlo espera antes de invocarOnValidSubmitoOnInvalidSubmit. - En un controlador
OnFieldChanged, llame aEditContext.RegisterAsyncFieldValidatorpara iniciar la validación de ese campo. Al iniciar otra validación para el mismo campo, se reemplaza y se cancela la operación anterior.
Para la validación asincrónica de nivel de formulario:
private void HandleValidationRequested(
object? sender, ValidationRequestedEventArgs e) =>
e.AddAsyncValidator(ValidateAsync);
private async Task ValidateAsync(CancellationToken cancellationToken)
{
var field = CurrentEditContext!.Field(nameof(Model.Username));
messages.Clear(field);
var available = await Http.GetFromJsonAsync<bool>(
$"api/usernames/available?value={Uri.EscapeDataString(Model.Username)}",
cancellationToken);
if (!available)
{
messages.Add(field, "The username is already taken.");
}
CurrentEditContext.NotifyValidationStateChanged();
}
Para la validación asincrónica de nivel de campo:
private void HandleFieldChanged(
object? sender, FieldChangedEventArgs e)
{
CurrentEditContext!.RegisterAsyncFieldValidator(
e.FieldIdentifier,
token => ValidateFieldAsync(e.FieldIdentifier, token));
}
Pase el token de cancelación proporcionado a I/O. Borre los mensajes anteriores antes de iniciar la operación, evite publicar resultados parciales después de una excepción y llame NotifyValidationStateChanged a después de actualizar los mensajes.
Se descarta una operación cancelada porque ha sido sustituida o porque se ha cancelado la validación. Otras excepciones colocan el campo o el formulario en estado defectuoso. Para mostrar el estado pendiente y con errores, consulte ASP.NET Core Blazor validación de formularios.
Para ver un componente completo que combina la validación asincrónica de nivel de formulario y por campo, consulte el ejemplo siguiente:
@implements IDisposable
@inject HttpClient Http
@* A validator component that runs asynchronous validation, both when the whole form is
validated on submit and per field as the user edits the Username field. *@
@code {
[CascadingParameter]
private EditContext? CurrentEditContext { get; set; }
[Parameter, EditorRequired]
public RegistrationModel Model { get; set; } = default!;
private ValidationMessageStore? messages;
protected override void OnInitialized()
{
ArgumentNullException.ThrowIfNull(CurrentEditContext);
messages = new ValidationMessageStore(CurrentEditContext);
CurrentEditContext.OnValidationRequested += OnValidationRequested;
CurrentEditContext.OnFieldChanged += OnFieldChanged;
}
// Registers asynchronous work for the whole form. EditForm awaits it before invoking
// OnValidSubmit.
private void OnValidationRequested(
object? sender, ValidationRequestedEventArgs e) =>
e.AddAsyncValidator(ValidateUsernameAsync);
// Registers asynchronous work for a single field. A new registration supersedes and
// cancels any validation already in flight for the field.
private void OnFieldChanged(object? sender, FieldChangedEventArgs e)
{
if (e.FieldIdentifier.FieldName != nameof(RegistrationModel.Username))
{
return;
}
CurrentEditContext!.RegisterAsyncFieldValidator(
e.FieldIdentifier,
token => CheckAsync(e.FieldIdentifier, token));
}
private Task ValidateUsernameAsync(CancellationToken token) =>
CheckAsync(CurrentEditContext!.Field(nameof(Model.Username)), token);
private async Task CheckAsync(FieldIdentifier field, CancellationToken token)
{
messages!.Clear(field);
var available = await Http.GetFromJsonAsync<bool>(
$"api/usernames/available?value={Uri.EscapeDataString(Model.Username)}",
token);
if (!available)
{
messages.Add(field, "The username is already taken.");
}
CurrentEditContext!.NotifyValidationStateChanged();
}
public void Dispose()
{
if (CurrentEditContext is not null)
{
CurrentEditContext.OnValidationRequested -= OnValidationRequested;
CurrentEditContext.OnFieldChanged -= OnFieldChanged;
}
}
}
Para obtener atributos de validación asincrónica en el modelo, consulte Validación en ASP.NET Core.
El código del componente de validador se ejecuta donde se ejecuta el componente. En Interactive WebAssembly, se ejecuta en el explorador, mientras se ejecuta en el servidor a través del circuito en Interactive Server.
En SSR estático, el código del componente validador se ejecuta en el servidor durante el envío del formulario y no proporciona validación en tiempo real de campos de .NET entre una solicitud y otra.
Validación remota con WebAssembly interactivo
La validación remota envía datos de formulario desde un componente WebAssembly interactivo a un punto de conexión de servidor y agrega errores de campo devueltos al formulario EditContext. Resulta útil cuando una regla requiere datos privados del servidor, un servicio externo u otra lógica que no se debe ejecutar en el explorador.
El formulario:
- Ejecuta la validación de anotaciones de datos localmente.
- Envía una entrada válida localmente al punto de conexión desde
OnValidSubmit. - Recibe errores de validación con clave de campo del servidor.
- Agrega errores remotos al formulario a través del componente de validador.
OnValidSubmit solo significa que la validación local se realizó correctamente. Procese o guarde el modelo solo después de que la validación remota también se realice correctamente.
Importante
No envíe datos de validación privados ni reglas de negocio al explorador. El servidor debe validar cada solicitud de forma independiente porque se puede omitir la validación del lado cliente.
En este ejemplo se valida de forma remota cuando se envía el formulario. Para las comprobaciones remotas activas por campo, use el patrón asincrónico de validación de campos de Agregar validación asincrónica.
Si el formulario WebAssembly se representa previamente, sus servicios del lado cliente también deben estar disponibles durante la representación previa. Para conocer los enfoques disponibles, consulte Representación previa de componentes de ASP.NET Core Razor.
Validación con una API mínima
Llama a AddValidation en el proyecto del servidor para validar los parámetros de punto de conexión compatibles antes de que se ejecute el controlador.
Las Microsoft.Extensions.Validation API que se usan para los metadatos de validación generados son experimentales en .NET 10. Para obtener más información, consulte Validación en ASP.NET Core.
Si el modelo se declara en el .Client proyecto, registre sus metadatos de validación generados en ambos proyectos, tal como se describe en Validación en ASP.NET Core.
El punto de conexión agrega una regla de negocio privada y devuelve errores indexados por el nombre del miembro del modelo:
app.MapPost("/api/starships/validate", (StarshipModel model) =>
{
Dictionary<string, string[]> errors = [];
if (model.Classification == "Defense" &&
string.IsNullOrWhiteSpace(model.Description))
{
errors[nameof(model.Description)] =
["A defense ship requires a description."];
}
if (errors.Count > 0)
{
return Results.ValidationProblem(errors);
}
return Results.NoContent();
});
app.MapPost("/api/starships/validate", (StarshipModel model) =>
{
Dictionary<string, string[]> errors = [];
if (model.Classification == "Defense" &&
string.IsNullOrWhiteSpace(model.Description))
{
errors[nameof(model.Description)] =
["A defense ship requires a description."];
}
if (errors.Count > 0)
{
return Results.ValidationProblem(errors);
}
return Results.NoContent();
});
La validación automática rechaza las anotaciones de datos no válidas antes de que se ejecute el controlador.
ValidationProblem devuelve 400 Bad Request con una errors propiedad que contiene mensajes con clave de campo. La validación correcta devuelve 204 No Content.
Validación con un controlador de API
En una solución hospedada Blazor WebAssembly , coloque el modelo compartido en el Shared proyecto y validelo con un controlador de API en el Server proyecto. El [ApiController] atributo rechaza automáticamente las anotaciones de datos no válidas antes de que se ejecute la acción.
[ApiController]
[Route("api/starships/validate")]
public class StarshipValidationController : ControllerBase
{
[HttpPost]
public IActionResult Validate(StarshipModel model)
{
if (model.Classification == "Defense" &&
string.IsNullOrWhiteSpace(model.Description))
{
ModelState.AddModelError(
nameof(model.Description),
"A defense ship requires a description.");
}
if (!ModelState.IsValid)
{
return ValidationProblem(ModelState);
}
return NoContent();
}
}
Registrar y asignar controladores en el proyecto de servidor. El controlador devuelve 400 Bad Request con una respuesta cuando se produce un ValidationProblemDetails error en la validación y 204 No Content cuando se realiza correctamente.
Llamar al punto de conexión y mostrar errores
Registre un HttpClient en el proyecto WebAssembly con la dirección base de la aplicación:
builder.Services.AddScoped(sp =>
new HttpClient { BaseAddress = new Uri(builder.HostEnvironment.BaseAddress) });
builder.Services.AddScoped(sp =>
new HttpClient { BaseAddress = new Uri(builder.HostEnvironment.BaseAddress) });
Coloca el componente CustomValidation de Crear un componente validador en el formulario:
@page "/"
@using System.Net
@using System.Net.Http.Json
@using BlazorWebAppRemoteValidation.Client.Models
@inject HttpClient Http
<PageTitle>Remote validation</PageTitle>
<h1>Remote validation</h1>
<p>Local validation runs before the form calls the remote endpoint. The endpoint validates the model again and applies a private business rule that requires a description for defense ships.</p>
<EditForm Model="Model" OnValidSubmit="Submit">
<DataAnnotationsValidator />
<CustomValidation @ref="remoteErrors" />
<ValidationSummary />
<p>
<label>
Identifier:
<InputText id="identifier" @bind-Value="Model.Identifier" />
</label>
<ValidationMessage For="() => Model.Identifier" />
</p>
<p>
<label>
Classification:
<InputSelect id="classification" @bind-Value="Model.Classification">
<option value="">Select...</option>
<option value="Exploration">Exploration</option>
<option value="Defense">Defense</option>
</InputSelect>
</label>
<ValidationMessage For="() => Model.Classification" />
</p>
<p>
<label>
Description:
<InputText id="description" @bind-Value="Model.Description" />
</label>
<ValidationMessage For="() => Model.Description" />
</p>
<button id="submit" type="submit">Submit</button>
</EditForm>
@if (accepted)
{
<p id="accepted" role="status">The server accepted the form.</p>
}
@code {
private StarshipModel Model { get; } = new();
private CustomValidation? remoteErrors;
private bool accepted;
private async Task Submit()
{
accepted = false;
using var response = await Http.PostAsJsonAsync(
"api/starships/validate", Model);
if (response.IsSuccessStatusCode)
{
accepted = true;
return;
}
if (response.StatusCode == HttpStatusCode.BadRequest)
{
var problem = await response.Content
.ReadFromJsonAsync<ValidationProblemResponse>()
?? throw new InvalidOperationException(
"The validation response didn't contain a response body.");
remoteErrors!.DisplayErrors(problem.Errors);
return;
}
response.EnsureSuccessStatusCode();
}
private sealed record ValidationProblemResponse(
Dictionary<string, string[]> Errors);
}
@using System.Net
@using System.Net.Http.Json
@inject HttpClient Http
<EditForm Model="Model" OnValidSubmit="Submit">
<DataAnnotationsValidator />
<CustomValidation @ref="remoteErrors" />
<ValidationSummary />
...
</EditForm>
@code {
private StarshipModel Model { get; } = new StarshipModel();
private CustomValidation? remoteErrors;
private async Task Submit()
{
using var response = await Http.PostAsJsonAsync(
"api/starships/validate", Model);
if (response.IsSuccessStatusCode)
{
// Process or save the model.
return;
}
if (response.StatusCode == HttpStatusCode.BadRequest)
{
var problem = await response.Content
.ReadFromJsonAsync<ValidationProblemResponse>();
if (problem is not null)
{
remoteErrors!.DisplayErrors(problem.Errors);
}
return;
}
response.EnsureSuccessStatusCode();
}
private sealed class ValidationProblemResponse
{
public Dictionary<string, string[]> Errors { get; set; } =
new Dictionary<string, string[]>();
}
}
El componente de validador borra un error de campo remoto cuando ese campo cambia, por lo que el usuario puede corregir el valor y volver a enviarlo. Proteja el punto de conexión según los requisitos de seguridad de la aplicación; la autenticación y la autorización están fuera del ámbito de este ejemplo de validación.
El ejemplo completo de validación remota incluye el punto de conexión del host, el modelo compartido, el registro de validación entre ensamblados, el componente validador y el formulario interactivo de WebAssembly.
El ejemplo de validación remota de .NET 10 muestra el mismo flujo de validación en una aplicación automática interactiva con autenticación y un proxy del lado servidor.