[release-notes] ASP.NET Core in .NET 11 Preview 5

[danroth27]

ASP.NET Core release notes for .NET 11 Preview 5.

This component PR targets the base milestone branch release-notes/11.0-preview5 (umbrella PR: #10421). Review and edit the markdown here in isolation — when this PR merges into the base branch, the changes roll up into the umbrella PR.

Draft generated with the release-notes skill in this repo. Verify feature selection, code samples, API names, and contributor attributions before marking ready for review.

Co-authored-by: Copilot 223556219+Copilot@users.noreply.github.com

[danroth27]

@davpetr FYI: Generated ASP.NET Core release notes for .NET 11 Preview 5.

[Copilot]

Pull request overview

This PR adds ASP.NET Core component release notes for .NET 11 Preview 5, fitting into the preview milestone documentation set that rolls up into the umbrella release-notes PR.

Changes:

• Adds feature highlights for Blazor, QuickGrid, Kestrel, and OpenAPI updates.
• Adds bug-fix summaries grouped by ASP.NET Core area.
• Adds community contributor acknowledgements for the milestone.

[mikekistler]

Looks good with my one suggested change. 👍

[oroztocil]

I posted the re-worked sections as regular comments to avoid problems with code blocks inside suggestion blocks.

Feel free to make the sections shorter if there is too much detail. However, the original texts were confusing and leaking implementation details.

[oroztocil]

Suggested change

	- [Blazor SSR forms validate in the browser](#blazor-ssr-forms-validate-in-the-browser)
	- [Blazor forms support async validation](#blazor-forms-support-async-validation)
	- [Validation supports resource-based localization](#validation-supports-resource-based-localization)
	- [Blazor SSR supports client-side validation](#blazor-ssr-supports-client-side-validation)
	- [Blazor supports async form validation](#blazor-supports-async-form-validation)
	- [Blazor and Minimal APIs support localized validation errors](#blazor-and-minimal-apis-support-error-localization)

[oroztocil]

Blazor and Minimal APIs support error localization

Validation of Blazor forms and Minimal API endpoints gets first-class support for localization of error messages and property names. By default, localization uses language-specific RESX files deployed as part of the assembly.

builder.Services.AddValidation()
    .AddValidationLocalization<ValidationMessages>();
    // Resolves to ValidationMessages.en.resx, ValidationMessages.es.resx, ...

[ValidatableType]
public class ContactModel
{
    // Values of ErrorMessage are used as localization keys.
    [Required(ErrorMessage = "RequiredError")]
    [EmailAddress(ErrorMessage = "EmailError")]
    [Display(Name = "ContactEmail")]
    public string? Email { get; set; }
}

Applications can also register custom IStringLocalizerFactory implementations to read the localized strings from other sources such as databases or JSON files. User registered type takes precedence over the default RESX localization.

builder.Services.AddValidation()
    .AddValidationLocalization();
builder.Services.AddSingleton<IStringLocalizerFactory, DbStringLocalizerFactory>();

Applications can also configure a programmatic strategy for localization, removing the need to specify localization keys on every validation attribute.

builder.Services.AddValidation()
    .AddValidationLocalization<ValidationMessages>(options =>
    {
        options.ErrorMessageKeyProvider = ctx =>
            ctx.Attribute.ErrorMessage ?? $"{ctx.Attribute.GetType().Name}_Error";
    });

[ValidatableType]
public class ContactModel
{
    // Looks-up localized string for 'RequiredAttribute_Error' automatically.
    [Required]
    public string? Username { get; set; }
}

[oroztocil]

Blazor supports async form validation

Blazor forms get support for async validation rules such as database lookups or remote API calls. In any rendering mode, EditForm submit validation now properly awaits async validators end-to-end. In interactive modes, validator components can register per-field async tasks via EditContext.AddValidationTask The framework tracks them, cancels superseded tasks, and exposes progress status via IsValidationPending(field) and IsValidationFaulted(field).

While Preview 5 ships the building blocks for Blazor forms, the full built-in async validation experience will be enabled when the new asynchronous DataAnnotations APIs are released in a later Preview. These APIs will be fully supported by the existing DataAnnotationsValidator component.

<EditForm EditContext="editContext" OnSubmit="HandleSubmit">
    <InputText @bind-Value="model.Username" />
    @if (editContext.IsValidationPending(() => model.Username))
    {
        <span>Checking availability...</span>
    }
    <ValidationMessage For="() => model.Username" />
    <button type="submit">Register</button>
</EditForm>

@code {
    [Inject] public UserService Users { get; set; } = default!;

    private readonly RegistrationModel model = new();
    private EditContext editContext = default!;
    private ValidationMessageStore messages = default!;

    protected override void OnInitialized()
    {
        editContext = new EditContext(model);
        messages = new ValidationMessageStore(editContext);
        editContext.OnFieldChanged += (_, e) =>
        {
            if (e.FieldIdentifier.FieldName == nameof(model.Username))
            {
                var cts = new CancellationTokenSource();
                editContext.AddValidationTask(e.FieldIdentifier,
                    CheckAsync(e.FieldIdentifier, model.Username, cts.Token), cts);
            }
        };
    }

    private async Task CheckAsync(FieldIdentifier field, string value, CancellationToken ct)
    {
        messages.Clear(field);
        if (await Users.IsUsernameTakenAsync(value, ct))
        {
            messages.Add(field, "Username is taken.");
        }
        editContext.NotifyValidationStateChanged();
    }

    private async Task HandleSubmit() => await editContext.ValidateAsync();
}

[oroztocil]

Blazor SSR supports client-side validation

Blazor SSR forms now get instant, in-browser validation feedback without a server round-trip, matching the experience provided by interactive Blazor apps and MVC apps with unobtrusive validation. The .NET model remains the single source of truth for validation rules. The server renders metadata for the validation rules which are then enforced by the Blazor JS code on the client-side.

The feature is enabled by default for all SSR forms that include the DataAnnotationsValidator component. Both enhanced and non-enhanced forms are supported.

<EditForm Model="Model" Enhance FormName="registration" OnValidSubmit="HandleValidSubmit">
    <DataAnnotationsValidator />

    <div>
        <label for="Email">Email</label>
        <InputText @bind-Value="Model.Email" id="Email" />
        <ValidationMessage For="@(() => Model.Email)" />
    </div>

    <div>
        <label for="Password">Password</label>
        <InputText @bind-Value="Model.Password" id="Password" type="password" />
        <ValidationMessage For="@(() => Model.Password)" />
    </div>

    <div>
        <label for="ConfirmPassword">Confirm Password</label>
        <InputText @bind-Value="Model.ConfirmPassword" id="ConfirmPassword" type="password" />
        <ValidationMessage For="@(() => Model.ConfirmPassword)" />
    </div>

    <div>
        <button type="submit" id="submit-btn">Register</button>
    </div>
</EditForm>

public class RegistrationModel
{
    [Required]
    [EmailAddress]
    public string Email { get; set; }

    [Required]
    [StringLength(100, MinimumLength = 8)]
    public string Password { get; set; }

    [Required]
    [Compare("Password")]
    [Display(Name = "Confirm Password")]
    public string ConfirmPassword { get; set; }
}