Corrigez les chargements de données en double, le scintillement de l'interface utilisateur et les problèmes de persistance d'état lors de l'utilisation du prerendering dans les composants interactifs Blazor.
- Étoiles GitHub
- 5 942
- Fichiers
- 1
- Dernier commit
- 11 nov. 2026
- Licence
- MIT
- Outils autorisés
- —
Que fait la skill support-prerendering ?
Corrigez les chargements de données en double, le scintillement de l'interface utilisateur et les problèmes de persistance d'état lors de l'utilisation du prerendering dans les composants interactifs Blazor.
Résumé généré à partir du SKILL.md de la skill.
À propos du skill support-prerendering
Les développeurs qui conçoivent des applications Blazor utilisent ce SKILL pour résoudre les problèmes courants causés par la transition entre le prerendering HTML statique et les runtimes interactifs. Il traite des obstacles techniques spécifiques tels que les doubles appels de données dans OnInitializedAsync, le scintillement de l'interface utilisateur lors du transfert, et les exceptions de référence nulle lorsque les composants attendent des API réservées au navigateur. Ce SKILL fournit des méthodes pour gérer la persistance de l'état, garantissant que les données chargées lors du rendu serveur initial sont disponibles une fois la session interactive lancée.
Un agent doit charger ce SKILL lorsqu'un développeur doit implémenter l'attribut [PersistentState] ou le service PersistentComponentState pour synchroniser les données. Il est également utilisé pour désactiver le prerendering pour des composants spécifiques ou pour exclure certaines pages du routage interactif à l'aide de l'attribut [ExcludeFromInteractiveRouting]. En utilisant des outils comme RendererInfo.IsInteractive, les développeurs peuvent protéger l'exécution du code pour éviter les erreurs pendant la phase statique. Ce SKILL est destiné à la correction de bugs de prerendering existants plutôt qu'à la configuration initiale d'un projet ou à la création générale de composants.
Ce qu'un agent peut faire avec
- 1Prévenir les appels API en doubleAppliquez la persistance d'état pour garantir que les données chargées pendant le prerendering ne sont pas récupérées une seconde fois lorsque le runtime interactif s'attache.
- 2Désactiver le prerendering pour des composants spécifiquesDésactivez le prerendering pour les composants qui nécessitent un accès immédiat aux API du navigateur.
- 3Accéder à HttpContext sur des pages spécifiquesForcez un rechargement complet de la page pour les pages nécessitant l'accès aux cookies ou aux en-têtes de requête.
- 4Protéger le code exclusivement interactifUtilisez des vérifications au runtime pour vous assurer que certaines logiques ne s'exécutent qu'après l'attachement du runtime interactif.
Rédigé à partir du SKILL.md du skill. Chaque cas d'utilisation est vérifié par rapport à une citation de celui-ci.
Comment installer la skill support-prerendering
Chaque commande copie le dossier de la skill dans le répertoire des skills du client. Redémarrez le client ou démarrez une nouvelle session pour la charger.Installer la skill support-prerendering dans Plugin
/plugin marketplace add dotnet/skills /plugin install dotnet-blazor@dotnet-agent-skills
Installer la skill support-prerendering dans Claude Code
~/.claude/skills/support-prerendering/SKILL.md
$ npx degit dotnet/skills/plugins/dotnet-blazor/skills/support-prerendering ~/.claude/skills/support-prerenderingInstaller la skill support-prerendering dans Claude Code (project)
.claude/skills/support-prerendering/SKILL.md
$ npx degit dotnet/skills/plugins/dotnet-blazor/skills/support-prerendering .claude/skills/support-prerenderingInstaller la skill support-prerendering dans Codex
~/.agents/skills/support-prerendering/SKILL.md
$ npx degit dotnet/skills/plugins/dotnet-blazor/skills/support-prerendering ~/.agents/skills/support-prerenderingInstaller la skill support-prerendering dans Gemini CLI
~/.gemini/skills/support-prerendering/SKILL.md
$ npx degit dotnet/skills/plugins/dotnet-blazor/skills/support-prerendering ~/.gemini/skills/support-prerenderingInstaller la skill support-prerendering dans Claude.ai
npx degit dotnet/skills/plugins/dotnet-blazor/skills/support-prerendering support-prerendering && zip -r support-prerendering.zip support-prerendering # claude.ai → Customize → Skills → + → Create skill → Upload a skill → support-prerendering.zip
Vérifications automatisées
Exécuté le 15 nov. 2026Rapport complet →A réussi nos vérifications automatiques. Ce n'est pas un audit de sécurité : lisez les scripts avant de laisser un agent les exécuter. Fonctionnement des vérifications
- Dépôt source lié et accessibledotnet/skills/plugins/dotnet-blazor/skills/support-prerendering is public and reachablegithub.com/dotnet/skills/tree/HEAD/plugins/dotnet-blazor/ski ↗Réussi
- Licence open source (OSI)MITspdx.org/licenses/MIT.html ↗Réussi
- Commit ou version publiée au cours de l'année écouléeLast commit 2026-11-11github.com/dotnet/skills/commits ↗Réussi
- Aucun téléchargement-exécution ni vol d'identifiants dans les scriptsNo scripts in the skill folderRéussi
- Aucune instruction cachée dans SKILL.mdNo override phrases, safeguard switches, credential requests or hidden charactersgithub.com/dotnet/skills/blob/HEAD/plugins/dotnet-blazor/ski ↗Réussi
- Les outils préautorisés sont limitésNo pre-approved tools; the agent asks before using onegithub.com/dotnet/skills/blob/HEAD/plugins/dotnet-blazor/ski ↗Réussi
- SKILL.md respecte le format Agent SkillsValid name and description; says when to use it; 217 linesgithub.com/dotnet/skills/blob/HEAD/plugins/dotnet-blazor/ski ↗Réussi
SKILL.md
Voir sur GitHubSupport Prerendering
How Prerendering Works
Prerendering is on by default for all interactive render modes. The server renders the component as static HTML and ships it to the browser immediately. Then the interactive runtime (Server/WebAssembly) loads and re-renders the component with full interactivity.
This means:
OnInitializedAsyncruns twice — once during prerender (static), once when the interactive runtime attaches.OnAfterRenderAsyncis NOT called during prerender — only after the interactive render.- Internal navigation between interactive pages (interactive routing) skips prerendering — prerendering only happens on full page loads.
Step 1 — Read the Project's AGENTS.md
Check the project's AGENTS.md for the Interactivity Mode and Interactivity Scope:
| Mode | Prerendering applies? |
|---|---|
| None (Static SSR) | No — there's no interactive handoff |
| Server | Yes |
| WebAssembly | Yes |
| Auto | Yes |
If the mode is None, this skill doesn't apply.
Persist State Across Prerender → Interactive
The most common prerendering problem: data loaded in OnInitializedAsync during prerender is thrown away and re-fetched when the interactive runtime attaches. This causes flicker and duplicate API/DB calls.
Recommended: [PersistentState] attribute
Annotate properties to automatically serialize during prerender and restore on interactive activation:
@page "/forecasts"
@rendermode InteractiveServer
<h1>Weather</h1>
@if (Forecasts is null)
{
<p>Loading...</p>
}
else
{
@foreach (var f in Forecasts)
{
<p>@f.Date: @f.TemperatureC°C</p>
}
}
@code {
[PersistentState]
public WeatherForecast[]? Forecasts { get; set; }
protected override async Task OnInitializedAsync()
{
Forecasts ??= await ForecastService.GetForecastsAsync();
}
}
The ??= pattern is critical — it means "only fetch if the property wasn't already restored from prerender state."
Multiple instances of the same component
When the same component type appears multiple times, use @key to disambiguate state:
@foreach (var item in items)
{
<ItemCard @key="item.Id" />
}
Advanced: PersistentComponentState service
For complex scenarios (dynamic keys, custom serialization), use the imperative API:
@inject PersistentComponentState ApplicationState
@code {
private List<Order>? orders;
protected override async Task OnInitializedAsync()
{
ApplicationState.RegisterOnPersisting(PersistOrders);
if (!ApplicationState.TryTakeFromJson<List<Order>>("orders", out var restored))
{
orders = await OrderService.GetOrdersAsync();
}
else
{
orders = restored;
}
}
private Task PersistOrders()
{
ApplicationState.PersistAsJson("orders", orders);
return Task.CompletedTask;
}
}
Disable Prerendering
Disable prerendering when a component depends on browser APIs immediately or when the prerender+interactive double render causes problems you can't solve with [PersistentState].
On a component definition
@rendermode @(new InteractiveServerRenderMode(prerender: false))
Replace InteractiveServerRenderMode with InteractiveWebAssemblyRenderMode or InteractiveAutoRenderMode as needed.
On a component instance
<MyChart @rendermode="new InteractiveServerRenderMode(prerender: false)" />
On the entire app
In App.razor:
<HeadOutlet @rendermode="new InteractiveServerRenderMode(prerender: false)" />
<Routes @rendermode="new InteractiveServerRenderMode(prerender: false)" />
Note: A parent's prerendering setting overrides children. If <Routes> disables prerendering, individual pages cannot re-enable it.
Exclude Pages from Interactive Routing
In a globally interactive app, some pages may need HttpContext (cookies, request headers, response status codes). These pages must render via static SSR, not inside the interactive runtime.
Use [ExcludeFromInteractiveRouting]:
@page "/privacy"
@attribute [ExcludeFromInteractiveRouting]
<h1>Privacy Policy</h1>
This forces a full page reload when navigating to this page, exiting interactive routing. The page renders as static SSR with full HttpContext access.
In App.razor, conditionally apply the render mode:
<!DOCTYPE html>
<html>
<head>
<HeadOutlet @rendermode="RenderModeForPage" />
</head>
<body>
<Routes @rendermode="RenderModeForPage" />
<script src="_framework/blazor.web.js"></script>
</body>
</html>
@code {
[CascadingParameter]
public HttpContext HttpContext { get; set; } = default!;
private IComponentRenderMode? RenderModeForPage =>
HttpContext.AcceptsInteractiveRouting() ? InteractiveServer : null;
}
Replace InteractiveServer with the app's configured render mode.
Detect Prerender vs Interactive at Runtime
Use RendererInfo to guard code that should only run interactively:
protected override async Task OnInitializedAsync()
{
if (RendererInfo.IsInteractive)
{
// Only runs during the interactive render, not during prerender
await StartSignalRConnection();
}
}
RendererInfo properties:
IsInteractive—falseduring prerender,trueafter interactive runtime attachesName—"Static"during prerender,"Server"or"WebAssembly"when interactive
Client Services Fail During Prerender
Components in the .Client project prerender on the server. Services registered only in the client Program.cs (e.g., IWebAssemblyHostEnvironment) won't be available during prerender.
Fix by one of:
- Register a matching service on the server — both
Program.csfiles provide the service - Make the service optional — use constructor injection with a nullable default:
public MyComponent(IMyService? svc = null) - Create a service abstraction — interface in
.Client, implementations in both projects - Disable prerendering for that component
Don'ts
- Don't call JS interop in
OnInitializedAsync— JS isn't available during prerender. UseOnAfterRenderAsync(firstRender). - Don't assume
OnInitializedAsyncruns once — it runs twice with prerendering. Always use[PersistentState]or??=guards. - Don't use
HttpContextin interactive components — it's only available during the static prerender, not during the interactive lifetime. Use[ExcludeFromInteractiveRouting]for pages that need it. - Don't disable prerendering as a first resort — it hurts perceived load time and SEO. Use
[PersistentState]to preserve state instead.
Fichiers de cette skill
1Questions sur la skill support-prerendering
Comment installer la skill support-prerendering dans Claude Code ?
Exécutez npx degit dotnet/skills/plugins/dotnet-blazor/skills/support-prerendering ~/.claude/skills/support-prerendering. Claude Code charge les skills depuis ~/.claude/skills (tous les projets) ou .claude/skills (un seul projet) et utilise une skill lorsque sa description correspond à la tâche.
Quels clients peuvent utiliser la skill support-prerendering ?
Tout client qui lit le format Agent Skills : Claude Code, Codex, Gemini CLI et claude.ai (envoi sous forme de ZIP). Les scripts de la skill ne s'exécutent que si le client autorise l'exécution de code.
Comment éviter les appels de données en double pendant le prerendering ?
Utilisez l'attribut [PersistentState] sur vos propriétés ou le service PersistentComponentState pour sérialiser les données pendant le prerender et les restaurer lorsque le runtime interactif s'attache.
Puis-je désactiver le prerendering pour un composant spécifique ?
Oui, vous pouvez le désactiver en passant un mode de rendu avec le paramètre prerender défini sur false, par exemple @rendermode @(new InteractiveServerRenderMode(prerender: false)).
Pourquoi mon interop JS échoue-t-il pendant OnInitializedAsync ?
JavaScript n'est pas disponible pendant la phase de prerender. Vous devez déplacer les appels d'interop JS vers la méthode OnAfterRenderAsync.