Declarative persistent component state updates (#35210)

Author: guardrex

Diff for: aspnetcore/blazor/components/integration.md

@@ -416,6 +416,11 @@ In the following example, the `{TYPE}` placeholder represents the type of data t
 @code {
     [SupplyParameterFromPersistentComponentState]
     public {TYPE} Data { get; set; }
+
+    protected override async Task OnInitializedAsync()
+    {
+        Data ??= await ...;
+    }
 }
 ```
 

Diff for: aspnetcore/blazor/components/lifecycle.md

@@ -646,7 +646,7 @@ else
 
     private async Task<string> LoadDataAsync()
     {
-        await Task.Delay(10000);
+        await Task.Delay(5000);
         return "Finished!";
     }
 }
@@ -701,7 +701,7 @@ else
 
     private async Task<string> LoadDataAsync()
     {
-        await Task.Delay(10000);
+        await Task.Delay(5000);
         return "Finished!";
     }
 

Diff for: aspnetcore/blazor/components/prerender.md

@@ -79,6 +79,55 @@ The following counter component example persists counter state during prerenderi
 
 <h1>Prerendered Counter 2</h1>
 
+<p role="status">Current count: @State?.CurrentCount</p>
+
+<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>
+
+@code {
+    [SupplyParameterFromPersistentComponentState]
+    public CounterState? State { get; set; }
+
+    protected override void OnInitialized()
+    {
+        if (State is null)
+        {
+            State = new() { CurrentCount = Random.Shared.Next(100) };
+            Logger.LogInformation("CurrentCount set to {Count}", 
+                State.CurrentCount);
+        }
+        else
+        {
+            Logger.LogInformation("CurrentCount restored to {Count}", 
+                State.CurrentCount);
+        }
+    }
+
+    private void IncrementCount()
+    {
+        if (State is not null)
+        {
+            State.CurrentCount++;
+        }
+    }
+
+    public class CounterState
+    {
+        public int CurrentCount { get; set; }
+    }
+}
+```
+
+<!-- HOLD until https://github.com/dotnet/aspnetcore/issues/61456 
+     is resolved
+
+```razor
+@page "/prerendered-counter-2"
+@inject ILogger<PrerenderedCounter2> Logger
+
+<PageTitle>Prerendered Counter 2</PageTitle>
+
+<h1>Prerendered Counter 2</h1>
+
 <p role="status">Current count: @CurrentCount</p>
 
 <button class="btn btn-primary" @onclick="IncrementCount">Click me</button>
@@ -89,13 +138,31 @@ The following counter component example persists counter state during prerenderi
 
     protected override void OnInitialized()
     {
-        CurrentCount ??= Random.Shared.Next(100);
-        Logger.LogInformation("CurrentCount set to {Count}", CurrentCount);
+        if (CurrentCount == 0)
+        {
+            CurrentCount = Random.Shared.Next(100);
+            Logger.LogInformation("CurrentCount set to {Count}", CurrentCount);
+        }
+        else
+        {
+            Logger.LogInformation("CurrentCount restored to {Count}", CurrentCount);
+        }
     }
 
     private void IncrementCount() => CurrentCount++;
 }
 ```
+-->
+
+When the component executes, `CurrentCount` is only set once during prerendering. The value is restored when the component is rerendered. The following is example output.
+
+> [!NOTE]
+> If the app adopts [interactive routing](xref:blazor/fundamentals/routing#static-versus-interactive-routing) and the page is reached via an internal [enhanced navigation](xref:blazor/fundamentals/routing#enhanced-navigation-and-form-handling), prerendering doesn't occur. Therefore, you must perform a full page reload for the component to see the following output. For more information, see the [Interactive routing and prerendering](#interactive-routing-and-prerendering) section.
+
+> :::no-loc text="info: BlazorSample.Components.Pages.PrerenderedCounter2[0]":::  
+> :::no-loc text="      CurrentCount set to 96":::  
+> :::no-loc text="info: BlazorSample.Components.Pages.PrerenderedCounter2[0]":::  
+> :::no-loc text="      CurrentCount restored to 96":::
 
 In the following example that serializes state for multiple components of the same type:
 
@@ -283,6 +350,16 @@ The following counter component example persists counter state during prerenderi
 }
 ```
 
+When the component executes, `currentCount` is only set once during prerendering. The value is restored when the component is rerendered. The following is example output.
+
+> [!NOTE]
+> If the app adopts [interactive routing](xref:blazor/fundamentals/routing#static-versus-interactive-routing) and the page is reached via an internal [enhanced navigation](xref:blazor/fundamentals/routing#enhanced-navigation-and-form-handling), prerendering doesn't occur. Therefore, you must perform a full page reload for the component to see the following output. For more information, see the [Interactive routing and prerendering](#interactive-routing-and-prerendering) section.
+
+> :::no-loc text="info: BlazorSample.Components.Pages.PrerenderedCounter3[0]":::  
+> :::no-loc text="      currentCount set to 96":::  
+> :::no-loc text="info: BlazorSample.Components.Pages.PrerenderedCounter3[0]":::  
+> :::no-loc text="      currentCount restored to 96":::
+
 :::moniker-end
 
 :::moniker range="< aspnetcore-10.0"
@@ -340,18 +417,18 @@ The following counter component example persists counter state during prerenderi
 
 :::code language="razor" source="~/../blazor-samples/8.0/BlazorSample_BlazorWebApp/Components/Pages/PrerenderedCounter2.razor":::
 
-:::moniker-end
-
 When the component executes, `currentCount` is only set once during prerendering. The value is restored when the component is rerendered. The following is example output.
 
 > [!NOTE]
-> If the app adopts [interactive routing](xref:blazor/fundamentals/routing#static-versus-interactive-routing) and the page is reached via an internal [enhanced navigation](xref:blazor/fundamentals/routing#enhanced-navigation-and-form-handling), prerendering doesn't occur. Therefore, you must perform a full page reload for the `PrerenderedCounter2` component to see the following output. For more information, see the [Interactive routing and prerendering](#interactive-routing-and-prerendering) section.
+> If the app adopts [interactive routing](xref:blazor/fundamentals/routing#static-versus-interactive-routing) and the page is reached via an internal [enhanced navigation](xref:blazor/fundamentals/routing#enhanced-navigation-and-form-handling), prerendering doesn't occur. Therefore, you must perform a full page reload for the component to see the following output. For more information, see the [Interactive routing and prerendering](#interactive-routing-and-prerendering) section.
 
 > :::no-loc text="info: BlazorSample.Components.Pages.PrerenderedCounter2[0]":::  
 > :::no-loc text="      currentCount set to 96":::  
 > :::no-loc text="info: BlazorSample.Components.Pages.PrerenderedCounter2[0]":::  
 > :::no-loc text="      currentCount restored to 96":::
 
+:::moniker-end
+
 By initializing components with the same state used during prerendering, any expensive initialization steps are only executed once. The rendered UI also matches the prerendered UI, so no flicker occurs in the browser.
 
 The persisted prerendered state is transferred to the client, where it's used to restore the component state. During client-side rendering (CSR, `InteractiveWebAssembly`), the data is exposed to the browser and must not contain sensitive, private information. During interactive server-side rendering (interactive SSR, `InteractiveServer`), [ASP.NET Core Data Protection](xref:security/data-protection/introduction) ensures that the data is transferred securely. The `InteractiveAuto` render mode combines WebAssembly and Server interactivity, so it's necessary to consider data exposure to the browser, as in the CSR case.