Hot reload: scope ShouldRender bypass to first render per component to prevent unbounded re-render loop (OOM)

[Copilot]

During a hot-reload metadata-update pass, ComponentBase.StateHasChanged bypassed ShouldRender() for the entire pass. Apps that rely on ShouldRender() == false to break a synchronous re-render cycle (component A renders → triggers B → B renders → triggers A → …) had that brake removed, causing an unbounded render loop that OOMs the process.

Description

Scopes the ShouldRender bypass to each component's first render in the hot-reload pass. On any subsequent StateHasChanged call within the same pass, ShouldRender() is evaluated normally, terminating the cycle. Every component still re-renders at least once (no stale UI) because the diff already force-calls SetDirectParameters top-down on every component regardless.

Motivation and Context

Apps hitting #67012 experienced memory growth to 6 GB+ and OS-level process kills after a hot reload. Root cause: IsRenderingOnMetadataUpdate was latched true for the entire synchronous pass, so every StateHasChanged call inside that pass bypassed ShouldRender, removing the only cycle-breaker in apps that relied on it.

Changes Made

• Renderer.cs — adds HashSet<int>? _hotReloadRenderedComponentIds (lazily allocated, nulled out after the pass — zero cost on the normal render path). New internal method IsFirstHotReloadRender(int componentId) uses HashSet.Add to return true the first time a component is seen in the pass.
• RenderHandle.cs — adds IsFirstHotReloadRender() delegating to the renderer.
• ComponentBase.cs — tightens the bypass condition:

  // Before
  if (_hasNeverRendered || ShouldRender() || _renderHandle.IsRenderingOnMetadataUpdate)
  
  // After
  if (_hasNeverRendered || ShouldRender() || (_renderHandle.IsRenderingOnMetadataUpdate && _renderHandle.IsFirstHotReloadRender()))

  The && short-circuit ensures the HashSet is only touched during a hot-reload pass.
• RendererTest.cs — regression test HotReload_ShouldRenderBypassScopedToFirstRender_TerminatesCyclicRenderLoop: two root components that mutually call StateHasChanged on each other from BuildRenderTree, both with ShouldRender() => false. Self-limits at 10 renders so CI fails fast without the fix rather than hanging/OOMing. Asserts each component renders exactly twice (once initial, once hot-reload forced).

How Has This Been Tested?

New regression test covers the cycle scenario directly. All 1,267 existing Microsoft.AspNetCore.Components.Tests tests continue to pass.

Types of changes

• Bug fix (non-breaking change which fixes an issue)
• New feature (non-breaking change which adds functionality)
• Breaking change (fix or feature that would cause existing functionality to not work as expected)
• Documentation update

Checklist

• My code follows the code style of this project.
• My change requires a change to the documentation.
• I have updated the documentation accordingly.
• I have read the CONTRIBUTING document.
• I have added tests to cover my changes.
• All new and existing tests passed.

[Copilot]

Pull request overview

This PR addresses a hot-reload regression in Blazor rendering where ComponentBase.StateHasChanged could bypass ShouldRender() for an entire metadata-update pass, enabling synchronous cyclic re-render loops that can lead to OOM. The fix scopes the ShouldRender bypass to the first hot-reload render per component, ensuring each component refreshes at least once while still allowing ShouldRender() == false to stop cycles on subsequent renders within the same pass.

Changes:

• Track per-pass “first hot reload render” per component via a lazily allocated HashSet<int> in Renderer, cleared after the metadata-update pass.
• Expose a renderer-backed RenderHandle.IsFirstHotReloadRender() helper and tighten ComponentBase.StateHasChanged to bypass ShouldRender() only on a component’s first hot-reload render.
• Add a regression test that reproduces the cyclic re-render loop scenario and asserts termination.

Reviewed changes

Copilot reviewed 4 out of 4 changed files in this pull request and generated 2 comments.

File	Description
src/Components/Components/src/RenderTree/Renderer.cs	Adds per-hot-reload-pass component tracking to scope the ShouldRender bypass.
src/Components/Components/src/RenderHandle.cs	Adds IsFirstHotReloadRender() hook used by ComponentBase during hot reload.
src/Components/Components/src/ComponentBase.cs	Updates StateHasChanged hot-reload bypass condition to require “first render in pass”.
src/Components/Components/test/RendererTest.cs	Adds regression test covering a cyclic StateHasChanged loop during hot reload.