From 15c3b0a4166df0e005ff2eb91e35af3494a63699 Mon Sep 17 00:00:00 2001
From: guardrex <1622880+guardrex@users.noreply.github.com>
Date: Wed, 27 Sep 2023 10:01:34 -0400
Subject: [PATCH 01/15] Prerender and Integrate work (Round 2)

---
 aspnetcore/blazor/components/integration.md   |  51 ++++---
 aspnetcore/blazor/components/prerendering.md  |  58 ++++---
 aspnetcore/blazor/fundamentals/signalr.md     |  12 ++
 aspnetcore/blazor/includes/prerendering.md    |   4 +-
 .../webassembly/additional-scenarios.md       |   4 +
 .../built-in/component-tag-helper.md          | 142 ++++++++++++++++--
 .../built-in/persist-component-state.md       |  34 +++--
 7 files changed, 222 insertions(+), 83 deletions(-)
diff --git a/aspnetcore/blazor/components/integration.md b/aspnetcore/blazor/components/integration.md
index 274f02655c23..a3c6a5107fe4 100644
--- a/aspnetcore/blazor/components/integration.md
+++ b/aspnetcore/blazor/components/integration.md
@@ -19,8 +19,6 @@ This article explains Razor component integration scenarios for ASP.NET Core app
 > [!IMPORTANT]
 > This article is currently undergoing updates for .NET 8. Please check back periodically for new content or when .NET 8 is released.
 
-<!-- UPDATE 8.0 HOLD
-
 Razor components can be integrated into Razor Pages and MVC apps. When the page or view is rendered, components can be prerendered at the same time.
   
 Prerendering can improve [Search Engine Optimization (SEO)](https://developer.mozilla.org/docs/Glossary/SEO) by rendering content for the initial HTTP response that search engines can use to calculate page rank.
@@ -36,25 +34,39 @@ After [configuring the project](#configuration), use the guidance in the followi
 
 Use the following guidance to integrate Razor components into pages and views of an existing Razor Pages or MVC app.
 
-1. Add an imports file to the root folder of the project with the following content. Change the `{APP NAMESPACE}` placeholder to the namespace of the project.
+1. Add a `Components` folder to the root folder of the project.
+
+1. Add an imports file to the `Components` folder with the following content. Change the `{APP NAMESPACE}` placeholder to the namespace of the project.
 
-   `_Imports.razor`:
+   `Components/_Imports.razor`:
 
    ```razor
    @using System.Net.Http
-   @using Microsoft.AspNetCore.Authorization
-   @using Microsoft.AspNetCore.Components.Authorization
+   @using System.Net.Http.Json
    @using Microsoft.AspNetCore.Components.Forms
    @using Microsoft.AspNetCore.Components.Routing
    @using Microsoft.AspNetCore.Components.Web
    @using Microsoft.AspNetCore.Components.Web.Virtualization
    @using Microsoft.JSInterop
    @using {APP NAMESPACE}
+   @using {APP NAMESPACE}.Components
    ```
 
+XXXXXXXXXXXXXXXXXXX
+
+ADD Layout folder
+Add NavMenu
+Add MainLayout
+ADD Routes
+ADD App
+
+XXXXXXXXXXXXXXXXXXX
+
 1. In the project's layout file (`Pages/Shared/_Layout.cshtml` in Razor Pages apps or `Views/Shared/_Layout.cshtml` in MVC apps):
 
-   * Add the following `<base>` tag and <xref:Microsoft.AspNetCore.Components.Web.HeadOutlet> component Tag Helper to the `<head>` element:
+   * Add the following `<base>` tag and <xref:Microsoft.AspNetCore.Components.Web.HeadOutlet> component via a [Component Tag Helper](xref:mvc/views/tag-helpers/builtin-th/component-tag-helper) to the `<head>` element:
+
+     <!-- UPDATE 8.0 ... I'm leaving the tilde ~ on the base href here. -->
 
      ```cshtml
      <base href="~/" />
@@ -66,21 +78,22 @@ Use the following guidance to integrate Razor components into pages and views of
 
      The <xref:Microsoft.AspNetCore.Components.Web.HeadOutlet> component is used to render head (`<head>`) content for page titles (<xref:Microsoft.AspNetCore.Components.Web.PageTitle> component) and other head elements (<xref:Microsoft.AspNetCore.Components.Web.HeadContent> component) set by Razor components. For more information, see <xref:blazor/components/control-head-content>.
 
-   * Add a `<script>` tag for the `blazor.server.js` script immediately before the `Scripts` render section (`@await RenderSectionAsync(...)`):
+   * Add a `<script>` tag for the `blazor.web.js` script immediately before the `Scripts` render section (`@await RenderSectionAsync(...)`):
 
      ```html
-     <script src="_framework/blazor.server.js"></script>
+     <script src="_framework/blazor.web.js"></script>
      ```
 
-     The framework adds the `blazor.server.js` script to the app. There's no need to manually add a `blazor.server.js` script file to the app.
+     The framework adds the `blazor.web.js` script to the app. There's no need to manually add a `blazor.web.js` script file to the app.
 
    > [!NOTE]
    > Typically, the layout loads via a `_ViewStart.cshtml` file.
 
-1. Register the Blazor Server services in `Program.cs` where services are registered:
+1. Register the Blazor services in `Program.cs` where services are registered:
 
    ```csharp
-   builder.Services.AddServerSideBlazor();
+   builder.Services.AddRazorComponents()
+       .AddServerComponents();
    ```
 
 1. Add the Blazor Hub endpoint to the endpoints of `Program.cs` where routes are mapped. Place the following line after the call to `MapRazorPages` (Razor Pages) or `MapControllerRoute` (MVC):
@@ -393,21 +406,9 @@ For more information, see <xref:blazor/components/index#class-name-and-namespace
 
 ## Persist prerendered state
 
-## Prerendered state size and SignalR message size limit
-
-A large prerendered state size may exceed the SignalR circuit message size limit, which results in the following:
-
-* The SignalR circuit fails to initialize with an error on the client: :::no-loc text="Circuit host not initialized.":::
-* The reconnection dialog on the client appears when the circuit fails. Recovery isn't possible.
-
-To resolve the problem, use ***either*** of the following approaches:
-
-* Reduce the amount of data that you are putting into the prerendered state.
-* Increase the [SignalR message size limit](xref:blazor/fundamentals/signalr#server-side-circuit-handler-options). ***WARNING***: Increasing the limit may increase the risk of Denial of service (DoS) attacks.
-
+-->
 
 ## Additional resources
 
 <xref:blazor/components/prerender>
 
--->
diff --git a/aspnetcore/blazor/components/prerendering.md b/aspnetcore/blazor/components/prerendering.md
index ca8d843968e5..42ab1291ba81 100644
--- a/aspnetcore/blazor/components/prerendering.md
+++ b/aspnetcore/blazor/components/prerendering.md
@@ -14,7 +14,7 @@ uid: blazor/components/prerender
 [!INCLUDE[](~/includes/not-latest-version.md)]
 -->
 
-This article explains Razor component prerendering scenarios for server-side Blazor apps.
+This article explains Razor component prerendering scenarios for server-rendered components in Blazor Web Apps.
   
 Prerendering can improve [Search Engine Optimization (SEO)](https://developer.mozilla.org/docs/Glossary/SEO) by rendering content for the initial HTTP response that search engines can use to calculate page rank.
 
@@ -28,11 +28,9 @@ Prerendering can improve [Search Engine Optimization (SEO)](https://developer.mo
 > [!IMPORTANT]
 > This section is currently undergoing updates for .NET 8.
 
-Without persisting prerendered state, state used during prerendering is lost and must be recreated when the app is fully loaded. If any state is setup asynchronously, the UI may flicker as the prerendered UI is replaced with temporary placeholders and then fully rendered again.
-
-<!-- UPDATE 8.0>
+<!-- UPDATE 8.0
 
-UPDATE 8.0 WORK IN PROGRESS ...
+Without persisting prerendered state, state used during prerendering is lost and must be recreated when the app is fully loaded. If any state is setup asynchronously, the UI may flicker as the prerendered UI is replaced with temporary placeholders and then fully rendered again.
 
 To solve these problems, Blazor supports persisting state in a prerendered page using the [Persist Component State Tag Helper](xref:mvc/views/tag-helpers/builtin-th/persist-component-state-tag-helper). Add the Tag Helper's tag, `<persist-component-state />`, inside the closing `</body>` tag.
 
@@ -133,28 +131,28 @@ By initializing components with the same state used during prerendering, any exp
 
 -->
 
-## Prerendered state size and SignalR message size limit
-
-A large prerendered state size may exceed the SignalR circuit message size limit, which results in the following:
-
-* The SignalR circuit fails to initialize with an error on the client: :::no-loc text="Circuit host not initialized.":::
-* The reconnection dialog on the client appears when the circuit fails. Recovery isn't possible.
-
-To resolve the problem, use ***either*** of the following approaches:
-
-* Reduce the amount of data that you are putting into the prerendered state.
-* Increase the [SignalR message size limit](xref:blazor/fundamentals/signalr#server-side-circuit-handler-options). ***WARNING***: Increasing the limit may increase the risk of Denial of service (DoS) attacks.
-
-## Additional resources
-
-* [State management: Handle prerendering](xref:blazor/state-management#handle-prerendering)
-* Razor component lifecycle subjects that pertain to prerendering
-  * [Component initialization (`OnInitialized{Async}`)](xref:blazor/components/lifecycle#component-initialization-oninitializedasync)
-  * [After component render (`OnAfterRender{Async}`)](xref:blazor/components/lifecycle#after-component-render-onafterrenderasync)
-  * [Stateful reconnection after prerendering](xref:blazor/components/lifecycle#stateful-reconnection-after-prerendering)
-  * [Prerendering with JavaScript interop](xref:blazor/components/lifecycle#prerendering-with-javascript-interop)
-* [Authentication and authorization: General aspects](xref:blazor/security/index#aspnet-core-blazor-authentication-and-authorization)
-* [Handle Errors: Prerendering](xref:blazor/fundamentals/handle-errors#prerendering)
-* [Host and deploy: Blazor Server](xref:blazor/host-and-deploy/server)
-* [Threat mitigation: Cross-site scripting (XSS)](xref:blazor/security/server/threat-mitigation#cross-site-scripting-xss)
-* <xref:Microsoft.AspNetCore.Components.Routing.Router.OnNavigateAsync> is executed *twice* when prerendering: [Handle asynchronous navigation events with `OnNavigateAsync`](xref:blazor/fundamentals/routing#handle-asynchronous-navigation-events-with-onnavigateasync)
+## Prerendering guidance
+
+Prerendering guidance is organized in the Blazor documentation by subject matter. The following links cover all of the prerendering guidance throughout the documentation set by subject:
+
+* Fundamentals
+  * <xref:Microsoft.AspNetCore.Components.Routing.Router.OnNavigateAsync> is executed *twice* when prerendering: [Handle asynchronous navigation events with `OnNavigateAsync`](xref:blazor/fundamentals/routing#handle-asynchronous-navigation-events-with-onnavigateasync)
+  * [Startup: Control headers in C# code](xref:blazor/fundamentals/startup#control-headers-in-c-code)
+  * [Handle Errors: Prerendering](xref:blazor/fundamentals/handle-errors#prerendering)
+  * [SignalR: Prerendered state size and SignalR message size limit](xref:blazor/fundamentals/signalr#prerendered-state-size-and-signalr-message-size-limit)
+* [Render modes: Prerendering](xref:blazor/components/render-modes@prerendering)
+* Components
+  * [Control `<head>` content during prerendering](xref:blazor/components/control-head-content#control-head-content-during-prerendering)
+  * Razor component lifecycle subjects that pertain to prerendering
+    * [Component initialization (`OnInitialized{Async}`)](xref:blazor/components/lifecycle#component-initialization-oninitializedasync)
+    * [After component render (`OnAfterRender{Async}`)](xref:blazor/components/lifecycle#after-component-render-onafterrenderasync)
+    * [Stateful reconnection after prerendering](xref:blazor/components/lifecycle#stateful-reconnection-after-prerendering)
+    * [Prerendering with JavaScript interop](xref:blazor/components/lifecycle#prerendering-with-javascript-interop): This section also appears in the two JS interop articles on calling JavaScript from .NET and calling .NET from JavaScript.
+  * [QuickGrid component sample app](xref:blazor/components/quickgrid#sample-app): The [**QuickGrid for Blazor** sample app](https://aspnet.github.io/quickgridsamples/) is hosted on GitHub Pages. The site loads fast thanks to static prerendering using the community-maintained [`BlazorWasmPrerendering.Build` GitHub project](https://github.com/jsakamoto/BlazorWasmPreRendering.Build).
+  * [Prerendering when integrating components into Razor Pages and MVC apps](xref:blazor/components/integration)
+* Authentication and authorization
+  * [Server-side threat mitigation: Cross-site scripting (XSS)](xref:blazor/security/server/threat-mitigation#cross-site-scripting-xss)
+  * [Unauthorized content display while prerendering with a custom `AuthenticationStateProvider`](xref:blazor/security/server/index#unauthorized-content-display-while-prerendering-with-a-custom-authenticationstateprovider)
+  * [WebAssembly prerendering support](xref:blazor/security/webassembly/index#prerendering-support)
+<!-- UPDATE 8.0 HOLD LINK FOR WORK AT DESTINATION * [Blazor WebAssembly rendered component authentication with prerendering](xref:blazor/security/webassembly/additional-scenarios#prerendering-with-authentication) -->
+* [State management: Handle prerendering](xref:blazor/state-management#handle-prerendering): Besides the *Handle prerendering* section, several of the article's other sections include remarks on prerendering.
diff --git a/aspnetcore/blazor/fundamentals/signalr.md b/aspnetcore/blazor/fundamentals/signalr.md
index afd6434d6193..e42c7bd4bdfc 100644
--- a/aspnetcore/blazor/fundamentals/signalr.md
+++ b/aspnetcore/blazor/fundamentals/signalr.md
@@ -105,6 +105,18 @@ If prerendering is configured, prerendering occurs before the client connection
 
 :::moniker-end
 
+## Prerendered state size and SignalR message size limit
+
+A large prerendered state size may exceed the SignalR circuit message size limit, which results in the following:
+
+* The SignalR circuit fails to initialize with an error on the client: :::no-loc text="Circuit host not initialized.":::
+* The reconnection dialog on the client appears when the circuit fails. Recovery isn't possible.
+
+To resolve the problem, use ***either*** of the following approaches:
+
+* Reduce the amount of data that you are putting into the prerendered state.
+* Increase the [SignalR message size limit](xref:blazor/fundamentals/signalr#server-side-circuit-handler-options). ***WARNING***: Increasing the limit may increase the risk of Denial of service (DoS) attacks.
+
 ## Additional client-side resources
 
 * [Secure a SignalR hub](xref:blazor/security/webassembly/index#secure-a-signalr-hub)
diff --git a/aspnetcore/blazor/includes/prerendering.md b/aspnetcore/blazor/includes/prerendering.md
index 4dcca493ae7d..370c9e13942c 100644
--- a/aspnetcore/blazor/includes/prerendering.md
+++ b/aspnetcore/blazor/includes/prerendering.md
@@ -12,7 +12,7 @@
 
 While an app is prerendering, certain actions, such as calling into JavaScript (JS), aren't possible.
 
-For the following example, the `setElementText1` function is placed inside the `<head>` element. The function is called with <xref:Microsoft.JSInterop.JSRuntimeExtensions.InvokeVoidAsync%2A?displayProperty=nameWithType> and doesn't return a value.
+For the following example, the `setElementText1` function is called with <xref:Microsoft.JSInterop.JSRuntimeExtensions.InvokeVoidAsync%2A?displayProperty=nameWithType> and doesn't return a value.
 
 > [!NOTE]
 > For general guidance on JS location and our recommendations for production apps, see <xref:blazor/js-interop/index#javascript-location>.
@@ -43,7 +43,7 @@ The [`OnAfterRender{Async}` lifecycle event](xref:blazor/components/lifecycle#af
 
 The following component demonstrates how to use JS interop as part of a component's initialization logic in a way that's compatible with prerendering. The component shows that it's possible to trigger a rendering update from inside <xref:Microsoft.AspNetCore.Components.ComponentBase.OnAfterRenderAsync%2A>. The developer must be careful to avoid creating an infinite loop in this scenario.
 
-For the following example, the `setElementText2` function is placed inside the `<head>` element. The function is called with <xref:Microsoft.JSInterop.IJSRuntime.InvokeAsync%2A?displayProperty=nameWithType> and returns a value.
+For the following example, the `setElementText2` function is called with <xref:Microsoft.JSInterop.IJSRuntime.InvokeAsync%2A?displayProperty=nameWithType> and returns a value.
 
 > [!NOTE]
 > For general guidance on JS location and our recommendations for production apps, see <xref:blazor/js-interop/index#javascript-location>.
diff --git a/aspnetcore/blazor/security/webassembly/additional-scenarios.md b/aspnetcore/blazor/security/webassembly/additional-scenarios.md
index 95dc0c826ab7..50106251c819 100644
--- a/aspnetcore/blazor/security/webassembly/additional-scenarios.md
+++ b/aspnetcore/blazor/security/webassembly/additional-scenarios.md
@@ -1331,6 +1331,10 @@ Register the `CustomAccountFactory` for the authentication provider in use. Any
 
 For an additional example that works with ME-ID security groups and ME-ID Administrator Roles and a custom user account class, see <xref:blazor/security/webassembly/meid-groups-roles>.
 
+<!-- UPDATE 8.0 This entire scenario is based on hosted WASM.
+                A similar approach might need to be created
+                for WebAssembly rendering in BWAs -->
+
 :::moniker range="< aspnetcore-8.0"
 
 ## Prerendering with authentication
diff --git a/aspnetcore/mvc/views/tag-helpers/built-in/component-tag-helper.md b/aspnetcore/mvc/views/tag-helpers/built-in/component-tag-helper.md
index 72d684015351..2674e0d3e332 100644
--- a/aspnetcore/mvc/views/tag-helpers/built-in/component-tag-helper.md
+++ b/aspnetcore/mvc/views/tag-helpers/built-in/component-tag-helper.md
@@ -10,6 +10,8 @@ uid: mvc/views/tag-helpers/builtin-th/component-tag-helper
 ---
 # Component Tag Helper in ASP.NET Core
 
+The Component Tag Helper renders a Razor component in a Razor Pages page or MVC view.
+
 ## Prerequisites
 
 :::moniker range=">= aspnetcore-8.0"
@@ -37,9 +39,13 @@ Follow the guidance in the *Configuration* section of the <xref:blazor/component
 
 To render a component from a page or view, use the [Component Tag Helper](xref:Microsoft.AspNetCore.Mvc.TagHelpers.ComponentTagHelper) (`<component>` tag).
 
+:::moniker range="< aspnetcore-8.0"
+
 > [!NOTE]
 > Integrating Razor components into Razor Pages and MVC apps in a *hosted Blazor WebAssembly app* is supported in ASP.NET Core in .NET 5.0 or later.
 
+:::moniker-end
+
 <xref:Microsoft.AspNetCore.Mvc.Rendering.RenderMode> configures whether the component:
 
 * Is prerendered into the page.
@@ -85,28 +91,81 @@ Additional characteristics include:
 
 The following Component Tag Helper renders the `Counter` component in a page or view in a server-side Blazor app with `ServerPrerendered`:
 
+:::moniker range=">= aspnetcore-8.0"
+
 ```cshtml
 @addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
-@using {APP ASSEMBLY}.Pages
+@using {APP ASSEMBLY}.Components.Pages
 
 ...
 
 <component type="typeof(Counter)" render-mode="ServerPrerendered" />
 ```
 
-:::moniker range=">= aspnetcore-8.0"
+The preceding example assumes that the `Counter` component is in the app's `Components/Pages` folder. The placeholder `{APP ASSEMBLY}` is the app's assembly name (for example, `@using BlazorSample.Components.Pages`).
+
+The Component Tag Helper can also pass parameters to components. Consider the following `ColorfulCheckbox` component that sets the checkbox label's color and size.
+
+`Components/ColorfulCheckbox.razor`:
+
+```razor
+<label style="font-size:@(Size)px;color:@Color">
+    <input @bind="Value"
+           id="survey" 
+           name="blazor" 
+           type="checkbox" />
+    Enjoying Blazor?
+</label>
+
+@code {
+    [Parameter]
+    public bool Value { get; set; }
+
+    [Parameter]
+    public int Size { get; set; } = 8;
+
+    [Parameter]
+    public string Color { get; set; }
+
+    protected override void OnInitialized()
+    {
+        Size += 10;
+    }
+}
+```
 
-The preceding example assumes that the `Counter` component is in the app's *Pages* folder. The placeholder `{APP ASSEMBLY}` is the app's assembly name (for example, `@using BlazorSample.Pages`).
+The `Size` (`int`) and `Color` (`string`) [component parameters](xref:blazor/components/index#component-parameters) can be set by the Component Tag Helper:
+
+```cshtml
+@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
+@using {APP ASSEMBLY}.Components
+
+...
+
+<component type="typeof(ColorfulCheckbox)" render-mode="ServerPrerendered" 
+    param-Size="14" param-Color="@("blue")" />
+```
+
+The preceding example assumes that the `ColorfulCheckbox` component is in the `Components` folder. The placeholder `{APP ASSEMBLY}` is the app's assembly name (for example, `@using BlazorSample.Components`).
 
 :::moniker-end
 
 :::moniker range="< aspnetcore-8.0"
 
-The preceding example assumes that the `Counter` component is in the app's *Pages* folder. The placeholder `{APP ASSEMBLY}` is the app's assembly name (for example, `@using BlazorSample.Pages` or `@using BlazorSample.Client.Pages` in a hosted Blazor solution).
+```cshtml
+@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
+@using {APP ASSEMBLY}.Pages
+
+...
 
-:::moniker-end
+<component type="typeof(Counter)" render-mode="ServerPrerendered" />
+```
+
+The preceding example assumes that the `Counter` component is in the app's `Pages` folder. The placeholder `{APP ASSEMBLY}` is the app's assembly name (for example, `@using BlazorSample.Pages` or `@using BlazorSample.Client.Pages` in a hosted Blazor solution).
 
-The Component Tag Helper can also pass parameters to components. Consider the following `ColorfulCheckbox` component that sets the checkbox label's color and size:
+The Component Tag Helper can also pass parameters to components. Consider the following `ColorfulCheckbox` component that sets the checkbox label's color and size.
+
+`Shared/ColorfulCheckbox.razor`:
 
 ```razor
 <label style="font-size:@(Size)px;color:@Color">
@@ -138,7 +197,7 @@ The `Size` (`int`) and `Color` (`string`) [component parameters](xref:blazor/com
 
 ```cshtml
 @addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
-@using {APP ASSEMBLY}.Components
+@using {APP ASSEMBLY}.Shared
 
 ...
 
@@ -146,7 +205,9 @@ The `Size` (`int`) and `Color` (`string`) [component parameters](xref:blazor/com
     param-Size="14" param-Color="@("blue")" />
 ```
 
-The preceding example assumes that the `ColorfulCheckbox` component is in a *Components* folder. The placeholder `{APP ASSEMBLY}` is the app's assembly name (for example, `@using BlazorSample.Components`).
+The preceding example assumes that the `ColorfulCheckbox` component is in the `Shared` folder. The placeholder `{APP ASSEMBLY}` is the app's assembly name (for example, `@using BlazorSample.Shared`).
+
+:::moniker-end
 
 The following HTML is rendered in the page or view:
 
@@ -187,10 +248,52 @@ public class MyClass
 
 **The class must have a public parameterless constructor.**
 
-`Shared/MyComponent.razor`:
+:::moniker range=">= aspnetcore-8.0"
+
+`Components/ParameterComponent.razor`:
 
 ```razor
-<h2>MyComponent</h2>
+<h2>ParameterComponent</h2>
+
+<p>Int: @MyObject.MyInt</p>
+<p>String: @MyObject.MyString</p>
+
+@code
+{
+    [Parameter]
+    public MyClass MyObject { get; set; }
+}
+```
+
+`Pages/MyPage.cshtml`:
+
+```cshtml
+@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
+@using {APP ASSEMBLY}
+@using {APP ASSEMBLY}.Components
+
+...
+
+@{
+    var myObject = new MyClass();
+    myObject.MyInt = 7;
+    myObject.MyString = "Set by MyPage";
+}
+
+<component type="typeof(ParameterComponent)" render-mode="ServerPrerendered" 
+    param-MyObject="@myObject" />
+```
+
+The preceding example assumes that the `ParameterComponent` component is in the app's `Components`` folder. The placeholder `{APP ASSEMBLY}` is the app's assembly name (for example, `@using BlazorSample` and `@using BlazorSample.Components`). `MyClass` is in the app's namespace.
+
+:::moniker-end
+
+:::moniker range="< aspnetcore-8.0"
+
+`Shared/ParameterComponent.razor`:
+
+```razor
+<h2>ParameterComponent</h2>
 
 <p>Int: @MyObject.MyInt</p>
 <p>String: @MyObject.MyString</p>
@@ -217,14 +320,29 @@ public class MyClass
     myObject.MyString = "Set by MyPage";
 }
 
-<component type="typeof(MyComponent)" render-mode="ServerPrerendered" 
+<component type="typeof(ParameterComponent)" render-mode="ServerPrerendered" 
     param-MyObject="@myObject" />
 ```
 
-The preceding example assumes that the `MyComponent` component is in the app's *Shared* folder. The placeholder `{APP ASSEMBLY}` is the app's assembly name (for example, `@using BlazorSample` and `@using BlazorSample.Shared`). `MyClass` is in the app's namespace.
+The preceding example assumes that the `ParameterComponent` component is in the app's `Shared`` folder. The placeholder `{APP ASSEMBLY}` is the app's assembly name (for example, `@using BlazorSample` and `@using BlazorSample.Shared`). `MyClass` is in the app's namespace.
+
+:::moniker-end
 
 ## Additional resources
 
+:::moniker range=">= aspnetcore-8.0"
+
+* <xref:blazor/components/prerender>
+* <xref:Microsoft.AspNetCore.Mvc.TagHelpers.ComponentTagHelper>
+* <xref:mvc/views/tag-helpers/intro>
+* <xref:blazor/components/index>
+
+:::moniker-end
+
+:::moniker range="< aspnetcore-8.0"
+
 * <xref:Microsoft.AspNetCore.Mvc.TagHelpers.ComponentTagHelper>
 * <xref:mvc/views/tag-helpers/intro>
 * <xref:blazor/components/index>
+
+:::moniker-end
diff --git a/aspnetcore/mvc/views/tag-helpers/built-in/persist-component-state.md b/aspnetcore/mvc/views/tag-helpers/built-in/persist-component-state.md
index 317a98e35331..f75b1ac1cfa6 100644
--- a/aspnetcore/mvc/views/tag-helpers/built-in/persist-component-state.md
+++ b/aspnetcore/mvc/views/tag-helpers/built-in/persist-component-state.md
@@ -10,17 +10,23 @@ uid: mvc/views/tag-helpers/builtin-th/persist-component-state-tag-helper
 ---
 # Persist Component State Tag Helper in ASP.NET Core
 
-<!-- UPDATE 8.0 Content is TBD for the general concepts here -->
-
-> [!IMPORTANT]
-> This article is currently undergoing updates for .NET 8. Please check back periodically for new content or when .NET 8 is released.
+The Persist Component State Tag Helper saves the state of Razor components rendered in a Razor Pages page or MVC view.
 
 ## Prerequisites
 
 :::moniker range=">= aspnetcore-8.0"
 
+<!-- UPDATE 8.0 Content is TBD for the general concepts here -->
+
+> [!IMPORTANT]
+> This section is currently undergoing updates for .NET 8.
+
+<!-- UPDATE 8.0
+
 Follow the guidance in the *Configuration* section of the <xref:blazor/components/integration> article.
 
+-->
+
 :::moniker-end
 
 :::moniker range="< aspnetcore-8.0"
@@ -71,22 +77,22 @@ For more information and examples, see <xref:blazor/components/prerendering-and-
 
 :::moniker-end
 
-## Prerendered state size and SignalR message size limit
-
-*This section only applies to server-side Blazor apps.*
+## Additional resources
 
-A large prerendered state size may exceed the SignalR circuit message size limit, which results in the following:
+:::moniker range=">= aspnetcore-8.0"
 
-* The SignalR circuit fails to initialize with an error on the client: :::no-loc text="Circuit host not initialized.":::
-* The reconnection dialog on the client appears when the circuit fails. Recovery isn't possible.
+* <xref:blazor/components/prerender>
+* <xref:Microsoft.AspNetCore.Mvc.TagHelpers.ComponentTagHelper>
+* <xref:mvc/views/tag-helpers/intro>
+* <xref:blazor/components/index>
 
-To resolve the problem, use ***either*** of the following approaches:
 
-* Reduce the amount of data that you are putting into the prerendered state.
-* Increase the [SignalR message size limit](xref:blazor/fundamentals/signalr#circuit-handler-options-for-blazor-server-apps). ***WARNING***: Increasing the limit may increase the risk of Denial of service (DoS) attacks.
+:::moniker-end
 
-## Additional resources
+:::moniker range="< aspnetcore-8.0"
 
 * <xref:Microsoft.AspNetCore.Mvc.TagHelpers.ComponentTagHelper>
 * <xref:mvc/views/tag-helpers/intro>
 * <xref:blazor/components/index>
+
+:::moniker-end

From bbfccaa737502bdf112aa4e06332a117a5eb14cf Mon Sep 17 00:00:00 2001
From: guardrex <1622880+guardrex@users.noreply.github.com>
Date: Wed, 27 Sep 2023 10:02:33 -0400
Subject: [PATCH 02/15] Updates

---
 aspnetcore/blazor/components/integration.md | 34 ++++++++++++---------
 1 file changed, 19 insertions(+), 15 deletions(-)

diff --git a/aspnetcore/blazor/components/integration.md b/aspnetcore/blazor/components/integration.md
index a3c6a5107fe4..8faa9e99cfb2 100644
--- a/aspnetcore/blazor/components/integration.md
+++ b/aspnetcore/blazor/components/integration.md
@@ -52,15 +52,7 @@ Use the following guidance to integrate Razor components into pages and views of
    @using {APP NAMESPACE}.Components
    ```
 
-XXXXXXXXXXXXXXXXXXX
 
-ADD Layout folder
-Add NavMenu
-Add MainLayout
-ADD Routes
-ADD App
-
-XXXXXXXXXXXXXXXXXXX
 
 1. In the project's layout file (`Pages/Shared/_Layout.cshtml` in Razor Pages apps or `Views/Shared/_Layout.cshtml` in MVC apps):
 
@@ -78,13 +70,13 @@ XXXXXXXXXXXXXXXXXXX
 
      The <xref:Microsoft.AspNetCore.Components.Web.HeadOutlet> component is used to render head (`<head>`) content for page titles (<xref:Microsoft.AspNetCore.Components.Web.PageTitle> component) and other head elements (<xref:Microsoft.AspNetCore.Components.Web.HeadContent> component) set by Razor components. For more information, see <xref:blazor/components/control-head-content>.
 
-   * Add a `<script>` tag for the `blazor.web.js` script immediately before the `Scripts` render section (`@await RenderSectionAsync(...)`):
+   * Add a `<script>` tag for the `blazor.server.js` script immediately before the `Scripts` render section (`@await RenderSectionAsync(...)`):
 
      ```html
-     <script src="_framework/blazor.web.js"></script>
+     <script src="_framework/blazor.server.js"></script>
      ```
 
-     The framework adds the `blazor.web.js` script to the app. There's no need to manually add a `blazor.web.js` script file to the app.
+     The framework adds the `blazor.server.js` script to the app. There's no need to manually add a `blazor.server.js` script file to the app.
 
    > [!NOTE]
    > Typically, the layout loads via a `_ViewStart.cshtml` file.
@@ -102,11 +94,13 @@ XXXXXXXXXXXXXXXXXXX
    app.MapBlazorHub();
    ```
 
-1. Integrate components into any page or view. For example, add a `Counter` component to the project's `Shared` folder.
+1. Integrate components into any page or view. For example, add a `Counter` component to the project's `Components` folder.
 
-   `Pages/Shared/Counter.razor` (Razor Pages) or `Views/Shared/Counter.razor` (MVC):
+   `Components/Counter.razor`:
 
    ```razor
+   @attribute [RenderModeServer]
+
    <h1>Counter</h1>
 
    <p>Current count: @currentCount</p>
@@ -131,7 +125,7 @@ XXXXXXXXXXXXXXXXXXX
 
    ```cshtml
    @page
-   @using {APP NAMESPACE}.Pages.Shared
+   @using {APP NAMESPACE}.Components
    @model IndexModel
    @{
        ViewData["Title"] = "Home page";
@@ -147,7 +141,7 @@ XXXXXXXXXXXXXXXXXXX
    `Views/Home/Index.cshtml`:
 
    ```cshtml
-   @using {APP NAMESPACE}.Views.Shared
+   @using {APP NAMESPACE}.Components
    @{
        ViewData["Title"] = "Home Page";
    }
@@ -159,6 +153,16 @@ For more information, see the [Render components from a page or view](#render-co
 
 ## Use routable components in a Razor Pages app
 
+XXXXXXXXXXXXXXXXXXX
+
+ADD Layout folder
+Add NavMenu (and change {APP NAME} to the app's name)
+Add MainLayout
+ADD Routes
+ADD App (and update APP NAMESPACE in stylesheet href)
+
+XXXXXXXXXXXXXXXXXXX
+
 *This section pertains to adding components that are directly routable from user requests.*
 
 To support routable Razor components in Razor Pages apps:

From 05e13a3a46d6c7a1e281250472619ada30ed4bd9 Mon Sep 17 00:00:00 2001
From: guardrex <1622880+guardrex@users.noreply.github.com>
Date: Thu, 28 Sep 2023 09:42:28 -0400
Subject: [PATCH 03/15] Updates

---
 aspnetcore/blazor/components/integration.md | 41 +++++++--------------
 1 file changed, 14 insertions(+), 27 deletions(-)

diff --git a/aspnetcore/blazor/components/integration.md b/aspnetcore/blazor/components/integration.md
index 8faa9e99cfb2..c5c49260579a 100644
--- a/aspnetcore/blazor/components/integration.md
+++ b/aspnetcore/blazor/components/integration.md
@@ -52,8 +52,6 @@ Use the following guidance to integrate Razor components into pages and views of
    @using {APP NAMESPACE}.Components
    ```
 
-
-
 1. In the project's layout file (`Pages/Shared/_Layout.cshtml` in Razor Pages apps or `Views/Shared/_Layout.cshtml` in MVC apps):
 
    * Add the following `<base>` tag and <xref:Microsoft.AspNetCore.Components.Web.HeadOutlet> component via a [Component Tag Helper](xref:mvc/views/tag-helpers/builtin-th/component-tag-helper) to the `<head>` element:
@@ -81,14 +79,13 @@ Use the following guidance to integrate Razor components into pages and views of
    > [!NOTE]
    > Typically, the layout loads via a `_ViewStart.cshtml` file.
 
-1. Register the Blazor services in `Program.cs` where services are registered:
+1. Register the server-side Blazor services in the `Program` file where services are registered:
 
    ```csharp
-   builder.Services.AddRazorComponents()
-       .AddServerComponents();
+   builder.Services.AddServerSideBlazor();
    ```
 
-1. Add the Blazor Hub endpoint to the endpoints of `Program.cs` where routes are mapped. Place the following line after the call to `MapRazorPages` (Razor Pages) or `MapControllerRoute` (MVC):
+1. Add the Blazor Hub endpoint to the endpoints of the `Program` file where routes are mapped. Place the following line after the call to `MapRazorPages` (Razor Pages) or `MapControllerRoute` (MVC):
 
    ```csharp
    app.MapBlazorHub();
@@ -99,8 +96,6 @@ Use the following guidance to integrate Razor components into pages and views of
    `Components/Counter.razor`:
 
    ```razor
-   @attribute [RenderModeServer]
-
    <h1>Counter</h1>
 
    <p>Current count: @currentCount</p>
@@ -153,25 +148,15 @@ For more information, see the [Render components from a page or view](#render-co
 
 ## Use routable components in a Razor Pages app
 
-XXXXXXXXXXXXXXXXXXX
-
-ADD Layout folder
-Add NavMenu (and change {APP NAME} to the app's name)
-Add MainLayout
-ADD Routes
-ADD App (and update APP NAMESPACE in stylesheet href)
-
-XXXXXXXXXXXXXXXXXXX
-
 *This section pertains to adding components that are directly routable from user requests.*
 
 To support routable Razor components in Razor Pages apps:
 
 1. Follow the guidance in the [Configuration](#configuration) section.
 
-1. Add an `App` component to the project root with the following content.
+1. Add an `App` component with the following content.
 
-   `App.razor`:
+   `Components/App.razor`:
 
    ```razor
    @using Microsoft.AspNetCore.Components.Routing
@@ -194,6 +179,7 @@ To support routable Razor components in Razor Pages apps:
    ```cshtml
    @page
    @addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
+   @using {APP NAMESPACE}.Components
 
    <component type="typeof(App)" render-mode="ServerPrerendered" />
    ```
@@ -208,15 +194,15 @@ To support routable Razor components in Razor Pages apps:
 
    For more information on the Component Tag Helper, including passing parameters and <xref:Microsoft.AspNetCore.Mvc.Rendering.RenderMode> configuration, see <xref:mvc/views/tag-helpers/builtin-th/component-tag-helper>.
 
-1. In the `Program.cs` endpoints, add a low-priority route for the `_Host` page as the last endpoint:
+1. In the the `Program` file endpoints, add a low-priority route for the `_Host` page as the last endpoint:
 
    ```csharp
    app.MapFallbackToPage("/_Host");
    ```
 
-1. Add routable components to the project. The following example is a `RoutableCounter` component based on the `Counter` component in the Blazor project templates.
+1. Create a `Components/Pages` folder in the app and add routable components. The following example is a `RoutableCounter` component based on the `Counter` component in the Blazor project templates.
 
-   `Pages/RoutableCounter.razor`:
+   `Components/Pages/RoutableCounter.razor`:
 
    ```razor
    @page "/routable-counter"
@@ -253,7 +239,7 @@ To support routable Razor components in MVC apps:
 
 1. Add an `App` component to the project root with the following content.
 
-   `App.razor`:
+   `Components/App.razor`:
 
    ```razor
    @using Microsoft.AspNetCore.Components.Routing
@@ -275,6 +261,7 @@ To support routable Razor components in MVC apps:
 
    ```cshtml
    @addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
+   @using {APP NAMESPACE}.Components
 
    <component type="typeof(App)" render-mode="ServerPrerendered" />
    ```
@@ -300,15 +287,15 @@ To support routable Razor components in MVC apps:
    }
    ```
 
-1. In the `Program.cs` endpoints, add a low-priority route for the controller action that returns the `_Host` view:
+1. In the `Program` file endpoints, add a low-priority route for the controller action that returns the `_Host` view:
 
    ```csharp
    app.MapFallbackToController("Blazor", "Home");
    ```
 
-1. Create a `Pages` folder in the MVC app and add routable components. The following example is a `RoutableCounter` component based on the `Counter` component in the Blazor project templates.
+1. Create a `Components/Pages` folder in the app and add routable components. The following example is a `RoutableCounter` component based on the `Counter` component in the Blazor project templates.
 
-   `Pages/RoutableCounter.razor`:
+   `Components/Pages/RoutableCounter.razor`:
 
    ```razor
    @page "/routable-counter"

From 70137d89b7274a2c6c4173be84e1cde46e9b2e79 Mon Sep 17 00:00:00 2001
From: guardrex <1622880+guardrex@users.noreply.github.com>
Date: Thu, 28 Sep 2023 09:47:30 -0400
Subject: [PATCH 04/15] Updates

---
 aspnetcore/blazor/components/prerendering.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/aspnetcore/blazor/components/prerendering.md b/aspnetcore/blazor/components/prerendering.md
index 42ab1291ba81..ed387cc664fc 100644
--- a/aspnetcore/blazor/components/prerendering.md
+++ b/aspnetcore/blazor/components/prerendering.md
@@ -140,7 +140,7 @@ Prerendering guidance is organized in the Blazor documentation by subject matter
   * [Startup: Control headers in C# code](xref:blazor/fundamentals/startup#control-headers-in-c-code)
   * [Handle Errors: Prerendering](xref:blazor/fundamentals/handle-errors#prerendering)
   * [SignalR: Prerendered state size and SignalR message size limit](xref:blazor/fundamentals/signalr#prerendered-state-size-and-signalr-message-size-limit)
-* [Render modes: Prerendering](xref:blazor/components/render-modes@prerendering)
+* [Render modes: Prerendering](xref:blazor/components/render-modes#prerendering)
 * Components
   * [Control `<head>` content during prerendering](xref:blazor/components/control-head-content#control-head-content-during-prerendering)
   * Razor component lifecycle subjects that pertain to prerendering

From 63e8d15d43880a58f687f50de091e87330050f21 Mon Sep 17 00:00:00 2001
From: guardrex <1622880+guardrex@users.noreply.github.com>
Date: Fri, 29 Sep 2023 07:57:50 -0400
Subject: [PATCH 05/15] Updates

---
 aspnetcore/blazor/components/integration.md | 403 +++++++++++++++-----
 1 file changed, 298 insertions(+), 105 deletions(-)

diff --git a/aspnetcore/blazor/components/integration.md b/aspnetcore/blazor/components/integration.md
index c5c49260579a..e49a339a6c40 100644
--- a/aspnetcore/blazor/components/integration.md
+++ b/aspnetcore/blazor/components/integration.md
@@ -14,23 +14,21 @@ uid: blazor/components/integration
 [!INCLUDE[](~/includes/not-latest-version.md)]
 -->
 
-This article explains Razor component integration scenarios for ASP.NET Core apps, including prerendering of Razor components on the server.
+> [!WARNING]
+> Guidance in this document pertains to the ***Release Candidate 2*** of .NET 8, which is targeted for release on October 10.
 
-> [!IMPORTANT]
-> This article is currently undergoing updates for .NET 8. Please check back periodically for new content or when .NET 8 is released.
+This article explains Razor component integration scenarios for ASP.NET Core apps, including prerendering of Razor components on the server.
 
-Razor components can be integrated into Razor Pages and MVC apps. When the page or view is rendered, components can be prerendered at the same time.
-  
-Prerendering can improve [Search Engine Optimization (SEO)](https://developer.mozilla.org/docs/Glossary/SEO) by rendering content for the initial HTTP response that search engines can use to calculate page rank.
+Razor components can be integrated into Razor Pages and MVC apps. When the page or view is rendered, components can be prerendered at the same time. Prerendering can improve [Search Engine Optimization (SEO)](https://developer.mozilla.org/docs/Glossary/SEO) by rendering content for the initial HTTP response that search engines can use to calculate page rank.
 
-After [configuring the project](#configuration), use the guidance in the following sections depending on the project's requirements:
+Use the guidance in the following sections depending on the project's requirements:
 
-* For components that are directly routable from user requests. Follow this guidance when visitors should be able to make an HTTP request in their browser for a component with an [`@page`](xref:mvc/views/razor#page) directive.
+* For interactive components that aren't directly routable from user requests, see the [Use non-routable components in pages or views](#use-non-routable-components-in-pages-or-views) section. Follow this guidance when the app embeds components into existing pages and views with the [Component Tag Helper](xref:mvc/views/tag-helpers/builtin-th/component-tag-helper).
+* For interactive components that are directly routable from user requests. Follow this guidance when visitors should be able to make an HTTP request in their browser for a component with an [`@page`](xref:mvc/views/razor#page) directive.
   * [Use routable components in a Razor Pages app](#use-routable-components-in-a-razor-pages-app)
   * [Use routable components in an MVC app](#use-routable-components-in-an-mvc-app)
-* For components that aren't directly routable from user requests, see the [Render components from a page or view](#render-components-from-a-page-or-view) section. Follow this guidance when the app embeds components into existing pages and views with the [Component Tag Helper](xref:mvc/views/tag-helpers/builtin-th/component-tag-helper).
 
-## Configuration
+## Use non-routable components in pages or views
 
 Use the following guidance to integrate Razor components into pages and views of an existing Razor Pages or MVC app.
 
@@ -56,8 +54,6 @@ Use the following guidance to integrate Razor components into pages and views of
 
    * Add the following `<base>` tag and <xref:Microsoft.AspNetCore.Components.Web.HeadOutlet> component via a [Component Tag Helper](xref:mvc/views/tag-helpers/builtin-th/component-tag-helper) to the `<head>` element:
 
-     <!-- UPDATE 8.0 ... I'm leaving the tilde ~ on the base href here. -->
-
      ```cshtml
      <base href="~/" />
      <component type="typeof(Microsoft.AspNetCore.Components.Web.HeadOutlet)" 
@@ -148,152 +144,355 @@ For more information, see the [Render components from a page or view](#render-co
 
 ## Use routable components in a Razor Pages app
 
-*This section pertains to adding components that are directly routable from user requests.*
+*This section pertains to adding interactive components that are directly routable from user requests.*
 
 To support routable Razor components in Razor Pages apps:
 
-1. Follow the guidance in the [Configuration](#configuration) section.
+Add a `Components` folder to the root folder of the project.
 
-1. Add an `App` component with the following content.
+Add an imports file to the `Components` folder with the following content. Change the `{APP NAMESPACE}` placeholder to the namespace of the project.
 
-   `Components/App.razor`:
+`Components/_Imports.razor`:
 
-   ```razor
-   @using Microsoft.AspNetCore.Components.Routing
+```razor
+@using System.Net.Http
+@using System.Net.Http.Json
+@using Microsoft.AspNetCore.Components.Forms
+@using Microsoft.AspNetCore.Components.Routing
+@using Microsoft.AspNetCore.Components.Web
+@using Microsoft.AspNetCore.Components.Web.Virtualization
+@using Microsoft.JSInterop
+@using {APP NAMESPACE}
+@using {APP NAMESPACE}.Components
+```
 
-   <Router AppAssembly="@typeof(App).Assembly">
-       <Found Context="routeData">
-           <RouteView RouteData="@routeData" />
-       </Found>
-       <NotFound>
-           <PageTitle>Not found</PageTitle>
-           <p role="alert">Sorry, there's nothing at this address.</p>
-       </NotFound>
-   </Router>
-   ```
+Add a `Layout` folder to the `Components` folder.
 
-1. Add a `_Host` page to the project with the following content. Replace the `{APP NAMESPACE}` placeholder with the app's namespace.
+Add a footer component and stylesheet.
 
-   `Pages/_Host.cshtml`:
+`Components/Layout/Footer.razor`:
 
-   ```cshtml
-   @page
-   @addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
-   @using {APP NAMESPACE}.Components
+```razor
+<footer class="border-top footer text-muted">
+    <div class="container">
+        &copy; 2023 - {APP TITLE} - <a href="/privacy">Privacy</a>
+    </div>
+</footer>
+```
 
-   <component type="typeof(App)" render-mode="ServerPrerendered" />
-   ```
+In the preceding markup, set the `{APP TITLE}` placeholder to the title of the app.
 
-   > [!NOTE]
-   > The preceding example assumes that the <xref:Microsoft.AspNetCore.Components.Web.HeadOutlet> component and Blazor script (`_framework/blazor.server.js`) are rendered by the app's layout. For more information, see the [Configuration](#configuration) section.
-  
-   <xref:Microsoft.AspNetCore.Mvc.Rendering.RenderMode> configures whether the `App` component:
+`Components/Layout/Footer.razor.css`:
+
+```css
+.footer {
+position: absolute;
+bottom: 0;
+width: 100%;
+white-space: nowrap;
+line-height: 60px;
+}
+```
 
-   * Is prerendered into the page.
-   * Is rendered as static HTML on the page or if it includes the necessary information to bootstrap a Blazor app from the user agent.
+Add a navigation menu component.
+
+`Components/Layout/NavMenu.razor`:
+
+```razor
+<nav class="navbar navbar-expand-sm navbar-toggleable-sm navbar-light bg-white border-bottom box-shadow mb-3">
+<div class="container">
+    <a class="navbar-brand" href="/">{APP TITLE}</a>
+    <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target=".navbar-collapse" aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation">
+        <span class="navbar-toggler-icon"></span>
+    </button>
+    <div class="navbar-collapse collapse d-sm-inline-flex justify-content-between">
+        <ul class="navbar-nav flex-grow-1">
+            <li class="nav-item">
+                <a class="nav-link text-dark" href="/">Home</a>
+            </li>
+            <li class="nav-item">
+                <a class="nav-link text-dark" href="/privacy">Privacy</a>
+            </li>
+            <li class="nav-item">
+                <a class="nav-link text-dark" href="/counter">Counter</a>
+            </li>
+        </ul>
+    </div>
+</div>
+</nav>
+```
 
-   For more information on the Component Tag Helper, including passing parameters and <xref:Microsoft.AspNetCore.Mvc.Rendering.RenderMode> configuration, see <xref:mvc/views/tag-helpers/builtin-th/component-tag-helper>.
+In the preceding markup, set the `{APP TITLE}` placeholder to the title of the app.
 
-1. In the the `Program` file endpoints, add a low-priority route for the `_Host` page as the last endpoint:
+`Components/Layout/NavMenu.razor.css`:
 
-   ```csharp
-   app.MapFallbackToPage("/_Host");
+```css
+a.navbar-brand {
+    white-space: normal;
+    text-align: center;
+    word-break: break-all;
+}
+
+a {
+    color: #0077cc;
+}
+
+.btn-primary {
+    color: #fff;
+    background-color: #1b6ec2;
+    border-color: #1861ac;
+}
+
+.nav-pills .nav-link.active, .nav-pills .show > .nav-link {
+    color: #fff;
+    background-color: #1b6ec2;
+    border-color: #1861ac;
+}
+
+.border-top {
+    border-top: 1px solid #e5e5e5;
+}
+
+.border-bottom {
+    border-bottom: 1px solid #e5e5e5;
+}
+
+.box-shadow {
+    box-shadow: 0 .25rem .75rem rgba(0, 0, 0, .05);
+}
+
+button.accept-policy {
+    font-size: 1rem;
+    line-height: inherit;
+}
    ```
 
-1. Create a `Components/Pages` folder in the app and add routable components. The following example is a `RoutableCounter` component based on the `Counter` component in the Blazor project templates.
+Add a main layout component and stylesheet.
 
-   `Components/Pages/RoutableCounter.razor`:
+`Components/Layout/MainLayout.razor`:
 
-   ```razor
-   @page "/routable-counter"
+```razor
+@inherits LayoutComponentBase
 
-   <PageTitle>Routable Counter</PageTitle>
+<header>
+    <NavMenu />
+</header>
 
-   <h1>Routable Counter</h1>
+<div class="container">
+    <main role="main" class="pb-3">
+        @Body
+    </main>
+</div>
 
-   <p>Current count: @currentCount</p>
+<Footer />
 
-   <button class="btn btn-primary" @onclick="IncrementCount">Click me</button>
+<div id="blazor-error-ui">
+    An unhandled error has occurred.
+    <a href="" class="reload">Reload</a>
+    <a class="dismiss">🗙</a>
+</div>
+```
 
-   @code {
-       private int currentCount = 0;
+`Components/Layout/MainLayout.razor.css`:
+
+```css
+#blazor-error-ui {
+    background: lightyellow;
+    bottom: 0;
+    box-shadow: 0 -1px 2px rgba(0, 0, 0, 0.2);
+    display: none;
+    left: 0;
+    padding: 0.6rem 1.25rem 0.7rem 1.25rem;
+    position: fixed;
+    width: 100%;
+    z-index: 1000;
+}
 
-       private void IncrementCount()
-       {
-           currentCount++;
-       }
-   }
-   ```
+#blazor-error-ui .dismiss {
+    cursor: pointer;
+    position: absolute;
+    right: 0.75rem;
+    top: 0.5rem;
+}
+```
 
-1. Run the project and navigate to the routable `RoutableCounter` component at `/routable-counter`.
+Add a `Routes` component to the `Components` folder with the following content.
+
+`Components/Routes.razor`:
+
+```razor
+<Router AppAssembly="@typeof(Program).Assembly">
+    <Found Context="routeData">
+        <RouteView RouteData="@routeData" DefaultLayout="@typeof(Layout.MainLayout)" />
+        <FocusOnNavigate RouteData="@routeData" Selector="h1" />
+    </Found>
+</Router>
+```
+
+Add an `App` component to the `Components` folder with the following content.
+
+`Components/App.razor`:
+
+```razor
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>{APP TITLE}</title>
+    <link rel="stylesheet" href="/lib/bootstrap/dist/css/bootstrap.min.css" />
+    <link rel="stylesheet" href="/css/site.css" />
+    <link rel="stylesheet" href="/{APP NAMESPACE}.styles.css" />
+    <HeadOutlet />
+</head>
+<body>
+    <Routes />
+    <script src="/lib/jquery/dist/jquery.min.js"></script>
+    <script src="/lib/bootstrap/dist/js/bootstrap.bundle.min.js"></script>
+    <script src="/js/site.js"></script>
+    <script src="_framework/blazor.web.js"></script>
+</body>
+</html>
+```
+
+> [!IMPORTANT]
+> The page title and stylesheet of routable components doesn't currently flow from the Razor Pages app and must be set manually:
+>
+> * For the `{APP TITLE}` placeholder in the `<title>` element, set the Razor Pages app title.
+> * For the `{APP NAMESPACE}` placeholder in the stylesheet `<link>` element, set the app's namespace.
+
+In the `Program` file where services are registered before the line that builds the app (`builder.Build()`), add services for Razor components and services to support rendering interactive server components:
+
+```csharp
+builder.Services.AddRazorComponents()
+    .AddInteractiveServerComponents();
+```
+
+<!-- UPDATE 8.0 Update API cross-link -->
+
+In the `Program` file immediately after the call to map Razor Pages (<xref:Microsoft.AspNetCore.Builder.RazorPagesEndpointRouteBuilderExtensions.MapRazorPages%2A>), call <xref:Microsoft.AspNetCore.Builder.RazorComponentsEndpointRouteBuilderExtensions.MapRazorComponents%2A> in the middleware processing pipeline to discover available components and specify the root component for the app, which by default is the `App` component (`App.razor`). Chain a call to `AddInteractiveServerRenderMode` <!-- <xref:Microsoft.AspNetCore.Builder.RazorComponentsEndpointConventionBuilder.AddInteractiveServerRenderMode%2A> --> to configure the Server render mode for the app:
+
+```csharp
+app.MapRazorComponents<App>()
+    .AddInteractiveServerRenderMode();
+```
+
+Create a `Pages` folder in the `Components` folder for routable components. The following example is a `RoutableCounter` component based on the `Counter` component in the Blazor project templates.
+
+`Components/Pages/Counter.razor`:
+
+```razor
+@page "/counter"
+@attribute [RenderModeInteractiveServer]
+
+<PageTitle>Counter</PageTitle>
+
+<h1>Counter</h1>
+
+<p>Current count: @currentCount</p>
+
+<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>
+
+@code {
+    private int currentCount = 0;
+
+    private void IncrementCount()
+    {
+        currentCount++;
+    }
+}
+```
+
+Run the project and navigate to the routable `Counter` component at `/counter`.
 
 For more information on namespaces, see the [Component namespaces](#component-namespaces) section.
 
 ## Use routable components in an MVC app
 
-*This section pertains to adding components that are directly routable from user requests.*
+*This section pertains to adding interactive components that are directly routable from user requests.*
 
 To support routable Razor components in MVC apps:
 
-1. Follow the guidance in the [Configuration](#configuration) section.
+1. Add a `Components` folder to the root folder of the project.
 
-1. Add an `App` component to the project root with the following content.
+1. Add an imports file to the `Components` folder with the following content. Change the `{APP NAMESPACE}` placeholder to the namespace of the project.
 
-   `Components/App.razor`:
+   `Components/_Imports.razor`:
 
    ```razor
+   @using System.Net.Http
+   @using System.Net.Http.Json
+   @using Microsoft.AspNetCore.Components.Forms
    @using Microsoft.AspNetCore.Components.Routing
+   @using Microsoft.AspNetCore.Components.Web
+   @using Microsoft.AspNetCore.Components.Web.Virtualization
+   @using Microsoft.JSInterop
+   @using {APP NAMESPACE}
+   @using {APP NAMESPACE}.Components
+   ```
+
+1. Add a `Routes` component to the `Components` folder with the following content.
 
-   <Router AppAssembly="@typeof(App).Assembly">
+   `Components/Routes.razor`:
+
+   ```razor
+   <Router AppAssembly="@typeof(Program).Assembly">
        <Found Context="routeData">
-           <RouteView RouteData="@routeData" />
+           <RouteView RouteData="@routeData" DefaultLayout="@typeof(Layout.MainLayout)" />
+           <FocusOnNavigate RouteData="@routeData" Selector="h1" />
        </Found>
-       <NotFound>
-           <PageTitle>Not found</PageTitle>
-           <p role="alert">Sorry, there's nothing at this address.</p>
-       </NotFound>
    </Router>
    ```
 
-1. Add a `_Host` view to the project with the following content. Replace the `{APP NAMESPACE}` placeholder with the app's namespace.
-
-   `Views/Home/_Host.cshtml`:
+1. Add an `App` component to the `Components` folder with the following content.
 
-   ```cshtml
-   @addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
-   @using {APP NAMESPACE}.Components
+   `Components/App.razor`:
 
-   <component type="typeof(App)" render-mode="ServerPrerendered" />
+   ```razor
+   <!DOCTYPE html>
+   <html lang="en">
+   <head>
+       <meta charset="utf-8" />
+       <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+       <title>{APP TITLE}</title>
+       <link rel="stylesheet" href="/lib/bootstrap/dist/css/bootstrap.min.css" />
+       <link rel="stylesheet" href="/css/site.css" />
+       <link rel="stylesheet" href="/{APP NAMESPACE}.styles.css" />
+       <HeadOutlet />
+   </head>
+   <body>
+       <Routes />
+       <script src="/lib/jquery/dist/jquery.min.js"></script>
+       <script src="/lib/bootstrap/dist/js/bootstrap.bundle.min.js"></script>
+       <script src="/js/site.js"></script>
+       <script src="_framework/blazor.web.js"></script>
+   </body>
+   </html>
    ```
 
-   > [!NOTE]
-   > The preceding example assumes that the <xref:Microsoft.AspNetCore.Components.Web.HeadOutlet> component and Blazor script (`_framework/blazor.server.js`) are rendered by the app's layout. For more information, see the [Configuration](#configuration) section.
-
-   <xref:Microsoft.AspNetCore.Mvc.Rendering.RenderMode> configures whether the `App` component:
-
-   * Is prerendered into the page.
-   * Is rendered as static HTML on the page or if it includes the necessary information to bootstrap a Blazor app from the user agent.
+   > [!IMPORTANT]
+   > The page title and stylesheet of routable components doesn't currently flow from the Razor Pages app and must be set manually:
+   >
+   > * For the `{APP TITLE}` placeholder in the `<title>` element, set the Razor Pages app title.
+   > * For the `{APP NAMESPACE}` placeholder in the stylesheet `<link>` element, set the app's namespace.
 
-   For more information on the Component Tag Helper, including passing parameters and <xref:Microsoft.AspNetCore.Mvc.Rendering.RenderMode> configuration, see <xref:mvc/views/tag-helpers/builtin-th/component-tag-helper>.
-
-1. Add an action to the Home controller.
-
-   `Controllers/HomeController.cs`:
+1. In the `Program` file where services are registered before the line that builds the app (`builder.Build()`), add services for Razor components and services to support rendering interactive server components:
 
    ```csharp
-   public IActionResult Blazor()
-   {
-      return View("_Host");
-   }
+   builder.Services.AddRazorComponents()
+       .AddInteractiveServerComponents();
    ```
 
-1. In the `Program` file endpoints, add a low-priority route for the controller action that returns the `_Host` view:
+<!-- UPDATE 8.0 Update API cross-link -->
+
+1. In the `Program` file immediately after the call to map Razor Pages (<xref:Microsoft.AspNetCore.Builder.RazorPagesEndpointRouteBuilderExtensions.MapRazorPages%2A>), call <xref:Microsoft.AspNetCore.Builder.RazorComponentsEndpointRouteBuilderExtensions.MapRazorComponents%2A> in the middleware processing pipeline to discover available components and specify the root component for the app, which by default is the `App` component (`App.razor`). Chain a call to `AddInteractiveServerRenderMode` <!-- <xref:Microsoft.AspNetCore.Builder.RazorComponentsEndpointConventionBuilder.AddInteractiveServerRenderMode%2A> --> to configure the Server render mode for the app:
 
    ```csharp
-   app.MapFallbackToController("Blazor", "Home");
+   app.MapRazorComponents<App>()
+       .AddInteractiveServerRenderMode();
    ```
 
-1. Create a `Components/Pages` folder in the app and add routable components. The following example is a `RoutableCounter` component based on the `Counter` component in the Blazor project templates.
+1. Create a `Pages` folder in the `Components` folder for routable components. The following example is a `RoutableCounter` component based on the `Counter` component in the Blazor project templates.
 
    `Components/Pages/RoutableCounter.razor`:
 
@@ -322,12 +521,6 @@ To support routable Razor components in MVC apps:
 
 For more information on namespaces, see the [Component namespaces](#component-namespaces) section.
 
-## Render components from a page or view
-
-*This section pertains to adding components to pages or views, where the components aren't directly routable from user requests.*
-
-To render a component from a page or view, use the [Component Tag Helper](xref:mvc/views/tag-helpers/builtin-th/component-tag-helper).
-
 ### Render stateful interactive components
 
 Stateful interactive components can be added to a Razor page or view.

From 445515befb18caf8a28354d30553db22c4310408 Mon Sep 17 00:00:00 2001
From: guardrex <1622880+guardrex@users.noreply.github.com>
Date: Fri, 29 Sep 2023 08:02:43 -0400
Subject: [PATCH 06/15] Updates

---
 aspnetcore/blazor/components/integration.md | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/aspnetcore/blazor/components/integration.md b/aspnetcore/blazor/components/integration.md
index e49a339a6c40..4fe281c870ba 100644
--- a/aspnetcore/blazor/components/integration.md
+++ b/aspnetcore/blazor/components/integration.md
@@ -140,8 +140,6 @@ Use the following guidance to integrate Razor components into pages and views of
    <component type="typeof(Counter)" render-mode="ServerPrerendered" />
    ```
 
-For more information, see the [Render components from a page or view](#render-components-from-a-page-or-view) section.
-
 ## Use routable components in a Razor Pages app
 
 *This section pertains to adding interactive components that are directly routable from user requests.*
@@ -308,12 +306,12 @@ Add a main layout component and stylesheet.
     z-index: 1000;
 }
 
-#blazor-error-ui .dismiss {
-    cursor: pointer;
-    position: absolute;
-    right: 0.75rem;
-    top: 0.5rem;
-}
+    #blazor-error-ui .dismiss {
+        cursor: pointer;
+        position: absolute;
+        right: 0.75rem;
+        top: 0.5rem;
+    }
 ```
 
 Add a `Routes` component to the `Components` folder with the following content.

From e79001a8a891b476a75cd8771e7a6c25ab79cc8f Mon Sep 17 00:00:00 2001
From: guardrex <1622880+guardrex@users.noreply.github.com>
Date: Fri, 29 Sep 2023 08:38:04 -0400
Subject: [PATCH 07/15] Updates

---
 aspnetcore/blazor/components/integration.md | 296 +++++++-------------
 1 file changed, 99 insertions(+), 197 deletions(-)

diff --git a/aspnetcore/blazor/components/integration.md b/aspnetcore/blazor/components/integration.md
index 4fe281c870ba..c94a332e20dc 100644
--- a/aspnetcore/blazor/components/integration.md
+++ b/aspnetcore/blazor/components/integration.md
@@ -24,127 +24,136 @@ Razor components can be integrated into Razor Pages and MVC apps. When the page
 Use the guidance in the following sections depending on the project's requirements:
 
 * For interactive components that aren't directly routable from user requests, see the [Use non-routable components in pages or views](#use-non-routable-components-in-pages-or-views) section. Follow this guidance when the app embeds components into existing pages and views with the [Component Tag Helper](xref:mvc/views/tag-helpers/builtin-th/component-tag-helper).
-* For interactive components that are directly routable from user requests. Follow this guidance when visitors should be able to make an HTTP request in their browser for a component with an [`@page`](xref:mvc/views/razor#page) directive.
-  * [Use routable components in a Razor Pages app](#use-routable-components-in-a-razor-pages-app)
-  * [Use routable components in an MVC app](#use-routable-components-in-an-mvc-app)
+* For interactive components that are directly routable from user requests, see the [Use routable components](#use-routable-components) section. Follow this guidance when visitors should be able to make an HTTP request in their browser for a component with an [`@page`](xref:mvc/views/razor#page) directive.
 
 ## Use non-routable components in pages or views
 
 Use the following guidance to integrate Razor components into pages and views of an existing Razor Pages or MVC app.
 
-1. Add a `Components` folder to the root folder of the project.
+Add a `Components` folder to the root folder of the project.
 
-1. Add an imports file to the `Components` folder with the following content. Change the `{APP NAMESPACE}` placeholder to the namespace of the project.
+Add an imports file to the `Components` folder with the following content. Change the `{APP NAMESPACE}` placeholder to the namespace of the project.
 
-   `Components/_Imports.razor`:
+`Components/_Imports.razor`:
 
-   ```razor
-   @using System.Net.Http
-   @using System.Net.Http.Json
-   @using Microsoft.AspNetCore.Components.Forms
-   @using Microsoft.AspNetCore.Components.Routing
-   @using Microsoft.AspNetCore.Components.Web
-   @using Microsoft.AspNetCore.Components.Web.Virtualization
-   @using Microsoft.JSInterop
-   @using {APP NAMESPACE}
-   @using {APP NAMESPACE}.Components
-   ```
+```razor
+@using System.Net.Http
+@using System.Net.Http.Json
+@using Microsoft.AspNetCore.Components.Forms
+@using Microsoft.AspNetCore.Components.Routing
+@using Microsoft.AspNetCore.Components.Web
+@using Microsoft.AspNetCore.Components.Web.Virtualization
+@using Microsoft.JSInterop
+@using {APP NAMESPACE}
+@using {APP NAMESPACE}.Components
+```
 
-1. In the project's layout file (`Pages/Shared/_Layout.cshtml` in Razor Pages apps or `Views/Shared/_Layout.cshtml` in MVC apps):
+In the project's layout file (`Pages/Shared/_Layout.cshtml` in Razor Pages apps or `Views/Shared/_Layout.cshtml` in MVC apps):
 
-   * Add the following `<base>` tag and <xref:Microsoft.AspNetCore.Components.Web.HeadOutlet> component via a [Component Tag Helper](xref:mvc/views/tag-helpers/builtin-th/component-tag-helper) to the `<head>` element:
+* Add the following `<base>` tag and <xref:Microsoft.AspNetCore.Components.Web.HeadOutlet> component via a [Component Tag Helper](xref:mvc/views/tag-helpers/builtin-th/component-tag-helper) to the `<head>` element:
 
-     ```cshtml
-     <base href="~/" />
-     <component type="typeof(Microsoft.AspNetCore.Components.Web.HeadOutlet)" 
-         render-mode="ServerPrerendered" />
-     ```
+  ```cshtml
+  <base href="~/" />
+  <component type="typeof(Microsoft.AspNetCore.Components.Web.HeadOutlet)" 
+      render-mode="ServerPrerendered" />
+  ```
 
-     The `href` value (the *app base path*) in the preceding example assumes that the app resides at the root URL path (`/`). If the app is a sub-application, follow the guidance in the *App base path* section of the <xref:blazor/host-and-deploy/index#app-base-path> article.
+  The `href` value (the *app base path*) in the preceding example assumes that the app resides at the root URL path (`/`). If the app is a sub-application, follow the guidance in the *App base path* section of the <xref:blazor/host-and-deploy/index#app-base-path> article.
 
-     The <xref:Microsoft.AspNetCore.Components.Web.HeadOutlet> component is used to render head (`<head>`) content for page titles (<xref:Microsoft.AspNetCore.Components.Web.PageTitle> component) and other head elements (<xref:Microsoft.AspNetCore.Components.Web.HeadContent> component) set by Razor components. For more information, see <xref:blazor/components/control-head-content>.
+  The <xref:Microsoft.AspNetCore.Components.Web.HeadOutlet> component is used to render head (`<head>`) content for page titles (<xref:Microsoft.AspNetCore.Components.Web.PageTitle> component) and other head elements (<xref:Microsoft.AspNetCore.Components.Web.HeadContent> component) set by Razor components. For more information, see <xref:blazor/components/control-head-content>.
 
-   * Add a `<script>` tag for the `blazor.server.js` script immediately before the `Scripts` render section (`@await RenderSectionAsync(...)`):
+* Add a `<script>` tag for the `blazor.web.js` script immediately before the `Scripts` render section (`@await RenderSectionAsync(...)`):
 
-     ```html
-     <script src="_framework/blazor.server.js"></script>
-     ```
+  ```html
+  <script src="_framework/blazor.web.js"></script>
+  ```
 
-     The framework adds the `blazor.server.js` script to the app. There's no need to manually add a `blazor.server.js` script file to the app.
+  The framework adds the `blazor.web.js` script to the app. There's no need to manually add a `blazor.web.js` script file to the app.
 
-   > [!NOTE]
-   > Typically, the layout loads via a `_ViewStart.cshtml` file.
+> [!NOTE]
+> Typically, the layout loads via a `_ViewStart.cshtml` file.
 
-1. Register the server-side Blazor services in the `Program` file where services are registered:
+In the `Program` file where services are registered before the line that builds the app (`builder.Build()`), add services for Razor components and services to support rendering interactive server components:
 
-   ```csharp
-   builder.Services.AddServerSideBlazor();
-   ```
+```csharp
+builder.Services.AddRazorComponents()
+    .AddInteractiveServerComponents();
+```
 
-1. Add the Blazor Hub endpoint to the endpoints of the `Program` file where routes are mapped. Place the following line after the call to `MapRazorPages` (Razor Pages) or `MapControllerRoute` (MVC):
+<!-- UPDATE 8.0 Update API cross-link -->
 
-   ```csharp
-   app.MapBlazorHub();
-   ```
+In the `Program` file immediately after the call to map Razor Pages (<xref:Microsoft.AspNetCore.Builder.RazorPagesEndpointRouteBuilderExtensions.MapRazorPages%2A>), call <xref:Microsoft.AspNetCore.Builder.RazorComponentsEndpointRouteBuilderExtensions.MapRazorComponents%2A> in the middleware processing pipeline to discover available components and specify the root component for the app, which by default is the `App` component (`App.razor`). Chain a call to `AddInteractiveServerRenderMode` <!-- <xref:Microsoft.AspNetCore.Builder.RazorComponentsEndpointConventionBuilder.AddInteractiveServerRenderMode%2A> --> to configure the Server render mode for the app:
 
-1. Integrate components into any page or view. For example, add a `Counter` component to the project's `Components` folder.
+```csharp
+app.MapRazorComponents<App>()
+    .AddInteractiveServerRenderMode();
+```
 
-   `Components/Counter.razor`:
+> [!NOTE]
+> If the app hasn't already been updated to include Antiforgery Middleware, add the following line after <xref:Microsoft.AspNetCore.Builder.AuthorizationAppBuilderExtensions.UseAuthorization%2A> is called:
+>
+> ```csharp
+> app.UseAntiforgery();
+> ```
 
-   ```razor
-   <h1>Counter</h1>
+Integrate components into any page or view. For example, add an `EmbeddedCounter` component to the project's `Components` folder.
 
-   <p>Current count: @currentCount</p>
+`Components/EmbeddedCounter.razor`:
 
-   <button class="btn btn-primary" @onclick="IncrementCount">Click me</button>
+```razor
+<h1>Embedded Counter</h1>
 
-   @code {
-       private int currentCount = 0;
+<p>Current count: @currentCount</p>
 
-       private void IncrementCount()
-       {
-           currentCount++;
-       }
-   }
-   ```
+<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>
 
-   **Razor Pages**:
+@code {
+    private int currentCount = 0;
 
-   In the project's `Index` page of a Razor Pages app, add the `Counter` component's namespace and embed the component into the page. When the `Index` page loads, the `Counter` component is prerendered in the page. In the following example, replace the `{APP NAMESPACE}` placeholder with the project's namespace.
+    private void IncrementCount()
+    {
+        currentCount++;
+    }
+}
+```
 
-   `Pages/Index.cshtml`:
+**Razor Pages**:
 
-   ```cshtml
-   @page
-   @using {APP NAMESPACE}.Components
-   @model IndexModel
-   @{
-       ViewData["Title"] = "Home page";
-   }
+In the project's `Index` page of a Razor Pages app, add the `EmbeddedCounter` component's namespace and embed the component into the page. When the `Index` page loads, the `EmbeddedCounter` component is prerendered in the page. In the following example, replace the `{APP NAMESPACE}` placeholder with the project's namespace.
 
-   <component type="typeof(Counter)" render-mode="ServerPrerendered" />
-   ```
+`Pages/Index.cshtml`:
+
+```cshtml
+@page
+@using {APP NAMESPACE}.Components
+@model IndexModel
+@{
+    ViewData["Title"] = "Home page";
+}
 
-   **MVC**:
+<component type="typeof(EmbeddedCounter)" render-mode="ServerPrerendered" />
+```
 
-   In the project's `Index` view of an MVC app, add the `Counter` component's namespace and embed the component into the view. When the `Index` view loads, the `Counter` component is prerendered in the page. In the following example, replace the `{APP NAMESPACE}` placeholder with the project's namespace.
+**MVC**:
 
-   `Views/Home/Index.cshtml`:
+In the project's `Index` view of an MVC app, add the `EmbeddedCounter` component's namespace and embed the component into the view. When the `Index` view loads, the `EmbeddedCounter` component is prerendered in the page. In the following example, replace the `{APP NAMESPACE}` placeholder with the project's namespace.
 
-   ```cshtml
-   @using {APP NAMESPACE}.Components
-   @{
-       ViewData["Title"] = "Home Page";
-   }
+`Views/Home/Index.cshtml`:
 
-   <component type="typeof(Counter)" render-mode="ServerPrerendered" />
-   ```
+```cshtml
+@using {APP NAMESPACE}.Components
+@{
+    ViewData["Title"] = "Home Page";
+}
+
+<component type="typeof(EmbeddedCounter)" render-mode="ServerPrerendered" />
+```
 
-## Use routable components in a Razor Pages app
+## Use routable components
 
-*This section pertains to adding interactive components that are directly routable from user requests.*
+Use the following guidance to integrate routable Razor components into an existing Razor Pages or MVC app.
 
-To support routable Razor components in Razor Pages apps:
+To support routable Razor components:
 
 Add a `Components` folder to the root folder of the project.
 
@@ -354,9 +363,9 @@ Add an `App` component to the `Components` folder with the following content.
 ```
 
 > [!IMPORTANT]
-> The page title and stylesheet of routable components doesn't currently flow from the Razor Pages app and must be set manually:
+> The page title and stylesheet of routable components doesn't currently flow from the app and must be set manually:
 >
-> * For the `{APP TITLE}` placeholder in the `<title>` element, set the Razor Pages app title.
+> * For the `{APP TITLE}` placeholder in the `<title>` element, set the app title.
 > * For the `{APP NAMESPACE}` placeholder in the stylesheet `<link>` element, set the app's namespace.
 
 In the `Program` file where services are registered before the line that builds the app (`builder.Build()`), add services for Razor components and services to support rendering interactive server components:
@@ -368,13 +377,20 @@ builder.Services.AddRazorComponents()
 
 <!-- UPDATE 8.0 Update API cross-link -->
 
-In the `Program` file immediately after the call to map Razor Pages (<xref:Microsoft.AspNetCore.Builder.RazorPagesEndpointRouteBuilderExtensions.MapRazorPages%2A>), call <xref:Microsoft.AspNetCore.Builder.RazorComponentsEndpointRouteBuilderExtensions.MapRazorComponents%2A> in the middleware processing pipeline to discover available components and specify the root component for the app, which by default is the `App` component (`App.razor`). Chain a call to `AddInteractiveServerRenderMode` <!-- <xref:Microsoft.AspNetCore.Builder.RazorComponentsEndpointConventionBuilder.AddInteractiveServerRenderMode%2A> --> to configure the Server render mode for the app:
+In the `Program` file immediately after the call to map Razor Pages (<xref:Microsoft.AspNetCore.Builder.RazorPagesEndpointRouteBuilderExtensions.MapRazorPages%2A>) or map controller routes (<xref:Microsoft.AspNetCore.Builder.ControllerEndpointRouteBuilderExtensions.MapControllerRoute%2A>), call <xref:Microsoft.AspNetCore.Builder.RazorComponentsEndpointRouteBuilderExtensions.MapRazorComponents%2A> in the middleware processing pipeline to discover available components and specify the root component for the app, which by default is the `App` component (`App.razor`). Chain a call to `AddInteractiveServerRenderMode` <!-- <xref:Microsoft.AspNetCore.Builder.RazorComponentsEndpointConventionBuilder.AddInteractiveServerRenderMode%2A> --> to configure the Server render mode for the app:
 
 ```csharp
 app.MapRazorComponents<App>()
     .AddInteractiveServerRenderMode();
 ```
 
+> [!NOTE]
+> If the app hasn't already been updated to include Antiforgery Middleware, add the following line after <xref:Microsoft.AspNetCore.Builder.AuthorizationAppBuilderExtensions.UseAuthorization%2A> is called:
+>
+> ```csharp
+> app.UseAntiforgery();
+> ```
+
 Create a `Pages` folder in the `Components` folder for routable components. The following example is a `RoutableCounter` component based on the `Counter` component in the Blazor project templates.
 
 `Components/Pages/Counter.razor`:
@@ -405,120 +421,6 @@ Run the project and navigate to the routable `Counter` component at `/counter`.
 
 For more information on namespaces, see the [Component namespaces](#component-namespaces) section.
 
-## Use routable components in an MVC app
-
-*This section pertains to adding interactive components that are directly routable from user requests.*
-
-To support routable Razor components in MVC apps:
-
-1. Add a `Components` folder to the root folder of the project.
-
-1. Add an imports file to the `Components` folder with the following content. Change the `{APP NAMESPACE}` placeholder to the namespace of the project.
-
-   `Components/_Imports.razor`:
-
-   ```razor
-   @using System.Net.Http
-   @using System.Net.Http.Json
-   @using Microsoft.AspNetCore.Components.Forms
-   @using Microsoft.AspNetCore.Components.Routing
-   @using Microsoft.AspNetCore.Components.Web
-   @using Microsoft.AspNetCore.Components.Web.Virtualization
-   @using Microsoft.JSInterop
-   @using {APP NAMESPACE}
-   @using {APP NAMESPACE}.Components
-   ```
-
-1. Add a `Routes` component to the `Components` folder with the following content.
-
-   `Components/Routes.razor`:
-
-   ```razor
-   <Router AppAssembly="@typeof(Program).Assembly">
-       <Found Context="routeData">
-           <RouteView RouteData="@routeData" DefaultLayout="@typeof(Layout.MainLayout)" />
-           <FocusOnNavigate RouteData="@routeData" Selector="h1" />
-       </Found>
-   </Router>
-   ```
-
-1. Add an `App` component to the `Components` folder with the following content.
-
-   `Components/App.razor`:
-
-   ```razor
-   <!DOCTYPE html>
-   <html lang="en">
-   <head>
-       <meta charset="utf-8" />
-       <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-       <title>{APP TITLE}</title>
-       <link rel="stylesheet" href="/lib/bootstrap/dist/css/bootstrap.min.css" />
-       <link rel="stylesheet" href="/css/site.css" />
-       <link rel="stylesheet" href="/{APP NAMESPACE}.styles.css" />
-       <HeadOutlet />
-   </head>
-   <body>
-       <Routes />
-       <script src="/lib/jquery/dist/jquery.min.js"></script>
-       <script src="/lib/bootstrap/dist/js/bootstrap.bundle.min.js"></script>
-       <script src="/js/site.js"></script>
-       <script src="_framework/blazor.web.js"></script>
-   </body>
-   </html>
-   ```
-
-   > [!IMPORTANT]
-   > The page title and stylesheet of routable components doesn't currently flow from the Razor Pages app and must be set manually:
-   >
-   > * For the `{APP TITLE}` placeholder in the `<title>` element, set the Razor Pages app title.
-   > * For the `{APP NAMESPACE}` placeholder in the stylesheet `<link>` element, set the app's namespace.
-
-1. In the `Program` file where services are registered before the line that builds the app (`builder.Build()`), add services for Razor components and services to support rendering interactive server components:
-
-   ```csharp
-   builder.Services.AddRazorComponents()
-       .AddInteractiveServerComponents();
-   ```
-
-<!-- UPDATE 8.0 Update API cross-link -->
-
-1. In the `Program` file immediately after the call to map Razor Pages (<xref:Microsoft.AspNetCore.Builder.RazorPagesEndpointRouteBuilderExtensions.MapRazorPages%2A>), call <xref:Microsoft.AspNetCore.Builder.RazorComponentsEndpointRouteBuilderExtensions.MapRazorComponents%2A> in the middleware processing pipeline to discover available components and specify the root component for the app, which by default is the `App` component (`App.razor`). Chain a call to `AddInteractiveServerRenderMode` <!-- <xref:Microsoft.AspNetCore.Builder.RazorComponentsEndpointConventionBuilder.AddInteractiveServerRenderMode%2A> --> to configure the Server render mode for the app:
-
-   ```csharp
-   app.MapRazorComponents<App>()
-       .AddInteractiveServerRenderMode();
-   ```
-
-1. Create a `Pages` folder in the `Components` folder for routable components. The following example is a `RoutableCounter` component based on the `Counter` component in the Blazor project templates.
-
-   `Components/Pages/RoutableCounter.razor`:
-
-   ```razor
-   @page "/routable-counter"
-
-   <PageTitle>Routable Counter</PageTitle>
-
-   <h1>Routable Counter</h1>
-
-   <p>Current count: @currentCount</p>
-
-   <button class="btn btn-primary" @onclick="IncrementCount">Click me</button>
-
-   @code {
-       private int currentCount = 0;
-
-       private void IncrementCount()
-       {
-           currentCount++;
-       }
-   }
-   ```
-
-1. Run the project and navigate to the routable `RoutableCounter` component at `/routable-counter`.
-
-For more information on namespaces, see the [Component namespaces](#component-namespaces) section.
-
 ### Render stateful interactive components
 
 Stateful interactive components can be added to a Razor page or view.

From 11e58cfb2e36341055102a489b9ab885db4c4384 Mon Sep 17 00:00:00 2001
From: guardrex <1622880+guardrex@users.noreply.github.com>
Date: Fri, 29 Sep 2023 10:02:32 -0400
Subject: [PATCH 08/15] Updates

---
 aspnetcore/blazor/components/integration.md   | 66 +++----------------
 aspnetcore/blazor/components/prerendering.md  | 46 +++++++------
 .../built-in/component-tag-helper.md          | 16 ++---
 .../built-in/persist-component-state.md       | 33 +++++-----
 4 files changed, 59 insertions(+), 102 deletions(-)

diff --git a/aspnetcore/blazor/components/integration.md b/aspnetcore/blazor/components/integration.md
index c94a332e20dc..64632b418f12 100644
--- a/aspnetcore/blazor/components/integration.md
+++ b/aspnetcore/blazor/components/integration.md
@@ -28,7 +28,15 @@ Use the guidance in the following sections depending on the project's requiremen
 
 ## Use non-routable components in pages or views
 
-Use the following guidance to integrate Razor components into pages and views of an existing Razor Pages or MVC app.
+Use the following guidance to integrate Razor components into pages and views of an existing Razor Pages or MVC app with the [Component Tag Helper](xref:mvc/views/tag-helpers/builtin-th/component-tag-helper).
+
+When server prerendering is used and the page or view renders:
+
+* The component is prerendered with the page or view.
+* The initial component state used for prerendering is lost.
+* New component state is created when the SignalR connection is established.
+
+For more information on rendering modes, including non-interactive static component rendering, see <xref:mvc/views/tag-helpers/builtin-th/component-tag-helper>. To save the state of Razor components rendered in a page or view, see <xref:mvc/views/tag-helpers/builtin-th/persist-component-state-tag-helper>.
 
 Add a `Components` folder to the root folder of the project.
 
@@ -421,55 +429,6 @@ Run the project and navigate to the routable `Counter` component at `/counter`.
 
 For more information on namespaces, see the [Component namespaces](#component-namespaces) section.
 
-### Render stateful interactive components
-
-Stateful interactive components can be added to a Razor page or view.
-
-When the page or view renders:
-
-* The component is prerendered with the page or view.
-* The initial component state used for prerendering is lost.
-* New component state is created when the SignalR connection is established.
-
-The following Razor page renders a `Counter` component:
-
-```cshtml
-<h1>Razor Page</h1>
-
-<component type="typeof(Counter)" render-mode="ServerPrerendered" 
-    param-InitialValue="InitialValue" />
-
-@functions {
-    [BindProperty(SupportsGet=true)]
-    public int InitialValue { get; set; }
-}
-```
-
-For more information, see <xref:mvc/views/tag-helpers/builtin-th/component-tag-helper>.
-
-### Render noninteractive components
-
-In the following Razor page, the `Counter` component is statically rendered with an initial value that's specified using a form. Since the component is statically rendered, the component isn't interactive:
-
-```cshtml
-<h1>Razor Page</h1>
-
-<form>
-    <input type="number" asp-for="InitialValue" />
-    <button type="submit">Set initial value</button>
-</form>
-
-<component type="typeof(Counter)" render-mode="Static" 
-    param-InitialValue="InitialValue" />
-
-@functions {
-    [BindProperty(SupportsGet=true)]
-    public int InitialValue { get; set; }
-}
-```
-
-For more information, see <xref:mvc/views/tag-helpers/builtin-th/component-tag-helper>.
-
 ## Component namespaces
 
 When using a custom folder to hold the project's Razor components, add the namespace representing the folder to either the page/view or to the `_ViewImports.cshtml` file. In the following example:
@@ -485,13 +444,6 @@ The `_ViewImports.cshtml` file is located in the `Pages` folder of a Razor Pages
 
 For more information, see <xref:blazor/components/index#class-name-and-namespace>.
 
-<!-- UPDATE 8.0 This content will cross-link the section 
-                of the same name in the Prerendering article. 
-
-## Persist prerendered state
-
--->
-
 ## Additional resources
 
 <xref:blazor/components/prerender>
diff --git a/aspnetcore/blazor/components/prerendering.md b/aspnetcore/blazor/components/prerendering.md
index ed387cc664fc..cd0f00a2fd67 100644
--- a/aspnetcore/blazor/components/prerendering.md
+++ b/aspnetcore/blazor/components/prerendering.md
@@ -25,36 +25,29 @@ Prerendering can improve [Search Engine Optimization (SEO)](https://developer.mo
 
 ## Persist prerendered state
 
-> [!IMPORTANT]
-> This section is currently undergoing updates for .NET 8.
-
-<!-- UPDATE 8.0
-
 Without persisting prerendered state, state used during prerendering is lost and must be recreated when the app is fully loaded. If any state is setup asynchronously, the UI may flicker as the prerendered UI is replaced with temporary placeholders and then fully rendered again.
 
-To solve these problems, Blazor supports persisting state in a prerendered page using the [Persist Component State Tag Helper](xref:mvc/views/tag-helpers/builtin-th/persist-component-state-tag-helper). Add the Tag Helper's tag, `<persist-component-state />`, inside the closing `</body>` tag.
+To solve these problems, Blazor supports persisting state in a prerendered page using the <xref:Microsoft.AspNetCore.Components.PersistentComponentState> service (and for components embedded into pages or views of Razor Pages or MVC apps, the [Persist Component State Tag Helper](xref:mvc/views/tag-helpers/builtin-th/persist-component-state-tag-helper)).
 
-`Pages/_Host.cshtml`:
+Consider the following `PrerenderedCounter1` component, which is a version of the `Counter` component found in apps created from the Blazor project template. The component sets an initial counter value of 5 during prerendering. After the SignalR connection to the client is established, the component rerenders on the client, and the value of 5 is lost. The component's counter starts at zero.
 
-```cshtml
-<body>
-    ...
+`Components/Pages/PrerenderedCounter1.razor`:
+
+```razor
 
-    <persist-component-state />
-</body>
 ```
 
-Decide what state to persist using the <xref:Microsoft.AspNetCore.Components.PersistentComponentState> service. [`PersistentComponentState.RegisterOnPersisting`](xref:Microsoft.AspNetCore.Components.PersistentComponentState.RegisterOnPersisting%2A) registers a callback to persist the component state before the app is paused. The state is retrieved when the application resumes.
+To preserve prerendered state, decide what state to persist using the <xref:Microsoft.AspNetCore.Components.PersistentComponentState> service. [`PersistentComponentState.RegisterOnPersisting`](xref:Microsoft.AspNetCore.Components.PersistentComponentState.RegisterOnPersisting%2A) registers a callback to persist the component state before the app is paused. The state is retrieved when the application resumes. In this case, the `PrerenderedCounter` component should save the state of the counter.
+
+The following example is an updated version of the `PrerenderedCounter` component that persists counter state during prerendering and retrieves the state to initialize the component. 
 
-The following example is an updated version of the `FetchData` component in a hosted Blazor WebAssembly app based on the Blazor project template. The `WeatherForecastPreserveState` component persists weather forecast state during prerendering and then retrieves the state to initialize the component. The [Persist Component State Tag Helper](xref:mvc/views/tag-helpers/builtin-th/persist-component-state-tag-helper) persists the component state after all component invocations.
+<!-- The [Persist Component State Tag Helper](xref:mvc/views/tag-helpers/builtin-th/persist-component-state-tag-helper) persists the component state after all component invocations. -->
 
-`Pages/WeatherForecastPreserveState.razor`:
+`Components/Pages/PrerenderedCounter2.razor`:
 
 ```razor
 @page "/weather-forecast-preserve-state"
 @implements IDisposable
-@using BlazorSample.Shared
-@inject IWeatherForecastService WeatherForecastService
 @inject PersistentComponentState ApplicationState
 
 <PageTitle>Weather Forecast</PageTitle>
@@ -127,9 +120,24 @@ else
 }
 ```
 
-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.
 
--->
+
+Add the Tag Helper's tag, `<persist-component-state />`, inside the closing `</body>` tag.
+
+`Pages/_Host.cshtml`:
+
+```cshtml
+<body>
+    ...
+
+    <persist-component-state />
+</body>
+```
+
+
+
+
+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.
 
 ## Prerendering guidance
 
diff --git a/aspnetcore/mvc/views/tag-helpers/built-in/component-tag-helper.md b/aspnetcore/mvc/views/tag-helpers/built-in/component-tag-helper.md
index 2674e0d3e332..60d804bbca02 100644
--- a/aspnetcore/mvc/views/tag-helpers/built-in/component-tag-helper.md
+++ b/aspnetcore/mvc/views/tag-helpers/built-in/component-tag-helper.md
@@ -16,7 +16,7 @@ The Component Tag Helper renders a Razor component in a Razor Pages page or MVC
 
 :::moniker range=">= aspnetcore-8.0"
 
-Follow the guidance in the *Configuration* section of the <xref:blazor/components/integration> article.
+Follow the guidance in the *Use non-routable components in pages or views* section of the <xref:blazor/components/integration#use-non-routable-components-in-pages-or-views> article.
 
 :::moniker-end
 
@@ -89,20 +89,20 @@ Additional characteristics include:
 * While pages and views can use components, the converse isn't true. Components can't use view- and page-specific features, such as partial views and sections. To use logic from a partial view in a component, factor out the partial view logic into a component.
 * Rendering server components from a static HTML page isn't supported.
 
-The following Component Tag Helper renders the `Counter` component in a page or view in a server-side Blazor app with `ServerPrerendered`:
+The following Component Tag Helper renders the `EmbeddedCounter` component in a page or view in a server-side Blazor app with `ServerPrerendered`:
 
 :::moniker range=">= aspnetcore-8.0"
 
 ```cshtml
 @addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
-@using {APP ASSEMBLY}.Components.Pages
+@using {APP ASSEMBLY}.Components
 
 ...
 
-<component type="typeof(Counter)" render-mode="ServerPrerendered" />
+<component type="typeof(EmbeddedCounter)" render-mode="ServerPrerendered" />
 ```
 
-The preceding example assumes that the `Counter` component is in the app's `Components/Pages` folder. The placeholder `{APP ASSEMBLY}` is the app's assembly name (for example, `@using BlazorSample.Components.Pages`).
+The preceding example assumes that the `EmbeddedCounter` component is in the app's `Components` folder. The placeholder `{APP ASSEMBLY}` is the app's assembly name (for example, `@using BlazorSample.Components`).
 
 The Component Tag Helper can also pass parameters to components. Consider the following `ColorfulCheckbox` component that sets the checkbox label's color and size.
 
@@ -154,14 +154,14 @@ The preceding example assumes that the `ColorfulCheckbox` component is in the `C
 
 ```cshtml
 @addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
-@using {APP ASSEMBLY}.Pages
+@using {APP ASSEMBLY}.Shared
 
 ...
 
-<component type="typeof(Counter)" render-mode="ServerPrerendered" />
+<component type="typeof(EmbeddedCounter)" render-mode="ServerPrerendered" />
 ```
 
-The preceding example assumes that the `Counter` component is in the app's `Pages` folder. The placeholder `{APP ASSEMBLY}` is the app's assembly name (for example, `@using BlazorSample.Pages` or `@using BlazorSample.Client.Pages` in a hosted Blazor solution).
+The preceding example assumes that the `EmbeddedCounter` component is in the app's `Shared` folder. The placeholder `{APP ASSEMBLY}` is the app's assembly name (for example, `@using BlazorSample.Shared` or `@using BlazorSample.Client.Shared` in a hosted Blazor solution).
 
 The Component Tag Helper can also pass parameters to components. Consider the following `ColorfulCheckbox` component that sets the checkbox label's color and size.
 
diff --git a/aspnetcore/mvc/views/tag-helpers/built-in/persist-component-state.md b/aspnetcore/mvc/views/tag-helpers/built-in/persist-component-state.md
index f75b1ac1cfa6..525c02cc4052 100644
--- a/aspnetcore/mvc/views/tag-helpers/built-in/persist-component-state.md
+++ b/aspnetcore/mvc/views/tag-helpers/built-in/persist-component-state.md
@@ -10,22 +10,13 @@ uid: mvc/views/tag-helpers/builtin-th/persist-component-state-tag-helper
 ---
 # Persist Component State Tag Helper in ASP.NET Core
 
-The Persist Component State Tag Helper saves the state of Razor components rendered in a Razor Pages page or MVC view.
+The Persist Component State Tag Helper saves the state of non-routable Razor components rendered in a page or view of a Razor Pages or MVC app.
 
 ## Prerequisites
 
 :::moniker range=">= aspnetcore-8.0"
 
-<!-- UPDATE 8.0 Content is TBD for the general concepts here -->
-
-> [!IMPORTANT]
-> This section is currently undergoing updates for .NET 8.
-
-<!-- UPDATE 8.0
-
-Follow the guidance in the *Configuration* section of the <xref:blazor/components/integration> article.
-
--->
+Follow the guidance in the *Use non-routable components in pages or views* section of the <xref:blazor/components/integration#use-non-routable-components-in-pages-or-views> article.
 
 :::moniker-end
 
@@ -42,16 +33,23 @@ Follow the guidance in the *Configuration* section for either:
 
 :::moniker range=">= aspnetcore-8.0"
 
-<!-- UPDATE 8.0 Content is TBD for the general concepts here -->
+To persist state for prerendered components, use the [Persist Component State Tag Helper](xref:mvc/views/tag-helpers/builtin-th/persist-component-state-tag-helper) ([reference source](https://github.com/dotnet/aspnetcore/blob/main/src/Mvc/Mvc.TagHelpers/src/PersistComponentStateTagHelper.cs)). Add the Tag Helper's tag, `<persist-component-state />`, inside the closing `</body>` tag of the layout in an app that prerenders components.
 
-> [!IMPORTANT]
-> This section is currently undergoing updates for .NET 8.
+[!INCLUDE[](~/includes/aspnetcore-repo-ref-source-links.md)]
 
-<!-- UPDATE 8.0
+In `Pages/Shared/_Layout.cshtml` for embedded components that are either WebAssembly prerendered (`WebAssemblyPrerendered`) or server prerendered (`ServerPrerendered`):
 
-For more information, see <xref:blazor/components/prerender#persist-prerendered-state>.
+```cshtml
+<body>
+    ...
 
--->
+    <persist-component-state />
+</body>
+```
+
+Decide what state to persist using the <xref:Microsoft.AspNetCore.Components.PersistentComponentState> service. [`PersistentComponentState.RegisterOnPersisting`](xref:Microsoft.AspNetCore.Components.PersistentComponentState.RegisterOnPersisting%2A) registers a callback to persist the component state before the app is paused. The state is retrieved when the application resumes.
+
+For more information and examples, see <xref:blazor/components/prerendering#persist-prerendered-state>.
 
 :::moniker-end
 
@@ -86,7 +84,6 @@ For more information and examples, see <xref:blazor/components/prerendering-and-
 * <xref:mvc/views/tag-helpers/intro>
 * <xref:blazor/components/index>
 
-
 :::moniker-end
 
 :::moniker range="< aspnetcore-8.0"

From b0424da04a0f0a5b1880265dc0e363c59ff2f35d Mon Sep 17 00:00:00 2001
From: guardrex <1622880+guardrex@users.noreply.github.com>
Date: Fri, 29 Sep 2023 10:10:18 -0400
Subject: [PATCH 09/15] Updates

---
 .../mvc/views/tag-helpers/built-in/persist-component-state.md   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/aspnetcore/mvc/views/tag-helpers/built-in/persist-component-state.md b/aspnetcore/mvc/views/tag-helpers/built-in/persist-component-state.md
index 525c02cc4052..3e44594739ad 100644
--- a/aspnetcore/mvc/views/tag-helpers/built-in/persist-component-state.md
+++ b/aspnetcore/mvc/views/tag-helpers/built-in/persist-component-state.md
@@ -49,7 +49,7 @@ In `Pages/Shared/_Layout.cshtml` for embedded components that are either WebAsse
 
 Decide what state to persist using the <xref:Microsoft.AspNetCore.Components.PersistentComponentState> service. [`PersistentComponentState.RegisterOnPersisting`](xref:Microsoft.AspNetCore.Components.PersistentComponentState.RegisterOnPersisting%2A) registers a callback to persist the component state before the app is paused. The state is retrieved when the application resumes.
 
-For more information and examples, see <xref:blazor/components/prerendering#persist-prerendered-state>.
+For more information and examples, see <xref:blazor/components/prerender#persist-prerendered-state>.
 
 :::moniker-end
 

From 433f5714ebdf3c15edc159ecb9222ee420cc3612 Mon Sep 17 00:00:00 2001
From: guardrex <1622880+guardrex@users.noreply.github.com>
Date: Fri, 29 Sep 2023 12:37:58 -0400
Subject: [PATCH 10/15] Updates

---
 aspnetcore/blazor/components/integration.md  |   2 +
 aspnetcore/blazor/components/prerendering.md | 185 +++++++++++++------
 2 files changed, 128 insertions(+), 59 deletions(-)

diff --git a/aspnetcore/blazor/components/integration.md b/aspnetcore/blazor/components/integration.md
index 64632b418f12..1f136e419d61 100644
--- a/aspnetcore/blazor/components/integration.md
+++ b/aspnetcore/blazor/components/integration.md
@@ -14,6 +14,8 @@ uid: blazor/components/integration
 [!INCLUDE[](~/includes/not-latest-version.md)]
 -->
 
+<!-- UPDATE 8.0 Remove WARNING at RC2 -->
+
 > [!WARNING]
 > Guidance in this document pertains to the ***Release Candidate 2*** of .NET 8, which is targeted for release on October 10.
 
diff --git a/aspnetcore/blazor/components/prerendering.md b/aspnetcore/blazor/components/prerendering.md
index cd0f00a2fd67..b51fa1f45191 100644
--- a/aspnetcore/blazor/components/prerendering.md
+++ b/aspnetcore/blazor/components/prerendering.md
@@ -14,101 +14,161 @@ uid: blazor/components/prerender
 [!INCLUDE[](~/includes/not-latest-version.md)]
 -->
 
+<!--
+    NOTE: The console output block quotes in this topic use a double-space 
+    at the ends of lines to generate a bare return in block quote output.
+-->
+
 This article explains Razor component prerendering scenarios for server-rendered components in Blazor Web Apps.
   
 Prerendering can improve [Search Engine Optimization (SEO)](https://developer.mozilla.org/docs/Glossary/SEO) by rendering content for the initial HTTP response that search engines can use to calculate page rank.
 
-<!-- UPDATE 8.0 Remove IMPORTANT notice -->
+<!-- UPDATE 8.0 Remove WARNING at RC2 -->
 
-> [!IMPORTANT]
-> This article is currently undergoing updates for .NET 8. Please check back periodically for new content or when .NET 8 is released.
+> [!WARNING]
+> Guidance in this document pertains to the ***Release Candidate 2*** of .NET 8, which is targeted for release on October 10.
 
 ## Persist prerendered state
 
 Without persisting prerendered state, state used during prerendering is lost and must be recreated when the app is fully loaded. If any state is setup asynchronously, the UI may flicker as the prerendered UI is replaced with temporary placeholders and then fully rendered again.
 
-To solve these problems, Blazor supports persisting state in a prerendered page using the <xref:Microsoft.AspNetCore.Components.PersistentComponentState> service (and for components embedded into pages or views of Razor Pages or MVC apps, the [Persist Component State Tag Helper](xref:mvc/views/tag-helpers/builtin-th/persist-component-state-tag-helper)).
-
-Consider the following `PrerenderedCounter1` component, which is a version of the `Counter` component found in apps created from the Blazor project template. The component sets an initial counter value of 5 during prerendering. After the SignalR connection to the client is established, the component rerenders on the client, and the value of 5 is lost. The component's counter starts at zero.
+Consider the following `PrerenderedCounter1` component, which is a version of the `Counter` component found in apps created from the Blazor project template and that doesn't preserve the initial count (`currentCount`) during prerendering. The component sets an initial random counter value during prerendering. After the SignalR connection to the client is established, the component rerenders, and the initial count value is replaced when `OnInitialized` executes a second time.
 
 `Components/Pages/PrerenderedCounter1.razor`:
 
 ```razor
+@page "/prerendered-counter-1"
+@attribute [RenderModeInteractiveServer]
+@inject ILogger<PrerenderedCounter1> Logger
+
+<PageTitle>Counter</PageTitle>
 
+<h1>Counter</h1>
+
+<p role="status">Current count: @currentCount</p>
+
+<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>
+
+@code {
+    private int currentCount;
+    private Random r = new Random();
+
+    protected override void OnInitialized()
+    {
+        currentCount = r.Next(100);
+        Logger.LogInformation("currentCount set to {Count}", currentCount);
+    }
+
+    private void IncrementCount()
+    {
+        currentCount++;
+    }
+}
 ```
 
-To preserve prerendered state, decide what state to persist using the <xref:Microsoft.AspNetCore.Components.PersistentComponentState> service. [`PersistentComponentState.RegisterOnPersisting`](xref:Microsoft.AspNetCore.Components.PersistentComponentState.RegisterOnPersisting%2A) registers a callback to persist the component state before the app is paused. The state is retrieved when the application resumes. In this case, the `PrerenderedCounter` component should save the state of the counter.
+Run the app and inspect logging from the component:
 
-The following example is an updated version of the `PrerenderedCounter` component that persists counter state during prerendering and retrieves the state to initialize the component. 
+> :::no-loc text="info: BlazorSample.Components.Pages.PrerenderedCounter1[0]":::  
+> :::no-loc text="      currentCount set to 41":::  
+> :::no-loc text="info: BlazorSample.Components.Pages.PrerenderedCounter1[0]":::  
+> :::no-loc text="      currentCount set to 92":::
 
-<!-- The [Persist Component State Tag Helper](xref:mvc/views/tag-helpers/builtin-th/persist-component-state-tag-helper) persists the component state after all component invocations. -->
+The first logged count occurs during prerendering. The count is set again after prerendering when the component is rerendered. There's also a flicker in the UI when the count updates from 41 to 92.
 
-`Components/Pages/PrerenderedCounter2.razor`:
+To solve this problem, Blazor supports persisting state in a prerendered page using the <xref:Microsoft.AspNetCore.Components.PersistentComponentState> service (and for components embedded into pages or views of Razor Pages or MVC apps, the [Persist Component State Tag Helper](xref:mvc/views/tag-helpers/builtin-th/persist-component-state-tag-helper)).
+
+To preserve prerendered state, decide what state to persist using the <xref:Microsoft.AspNetCore.Components.PersistentComponentState> service. [`PersistentComponentState.RegisterOnPersisting`](xref:Microsoft.AspNetCore.Components.PersistentComponentState.RegisterOnPersisting%2A) registers a callback to persist the component state before the app is paused. The state is retrieved when the application resumes.
+
+In following example demonstrates the general pattern:
+
+* The `{TYPE}` placeholder represents the type of data to persist.
+* The `{TOKEN}` placeholder is a state identifier string.
 
 ```razor
-@page "/weather-forecast-preserve-state"
 @implements IDisposable
 @inject PersistentComponentState ApplicationState
 
-<PageTitle>Weather Forecast</PageTitle>
+...
+
+@code {
+    private {TYPE} data;
+    private PersistingComponentStateSubscription persistingSubscription;
 
-<h1>Weather forecast</h1>
+    protected override async Task OnInitializedAsync()
+    {
+        persistingSubscription = 
+            ApplicationState.RegisterOnPersisting(PersistData);
 
-<p>This component demonstrates fetching data from the server.</p>
+        if (!ApplicationState.TryTakeFromJson<{TYPE}>(
+            "{TOKEN}", out var restored))
+        {
+            data = await ...;
+        }
+        else
+        {
+            data = restored!;
+        }
+    }
 
-@if (forecasts == null)
-{
-    <p><em>Loading...</em></p>
-}
-else
-{
-    <table class="table">
-        <thead>
-            <tr>
-                <th>Date</th>
-                <th>Temp. (C)</th>
-                <th>Temp. (F)</th>
-                <th>Summary</th>
-            </tr>
-        </thead>
-        <tbody>
-            @foreach (var forecast in forecasts)
-            {
-                <tr>
-                    <td>@forecast.Date.ToShortDateString()</td>
-                    <td>@forecast.TemperatureC</td>
-                    <td>@forecast.TemperatureF</td>
-                    <td>@forecast.Summary</td>
-                </tr>
-            }
-        </tbody>
-    </table>
+    private Task PersistData()
+    {
+        ApplicationState.PersistAsJson("{TOKEN}", data);
+
+        return Task.CompletedTask;
+    }
+
+    void IDisposable.Dispose()
+    {
+        persistingSubscription.Dispose();
+    }
 }
+```
+
+The following counter component example persists counter state during prerendering and retrieves the state to initialize the component. 
+
+`Components/Pages/PrerenderedCounter2.razor`:
+
+```razor
+@page "/prerendered-counter-2"
+@attribute [RenderModeInteractiveServer]
+@implements IDisposable
+@inject ILogger<PrerenderedCounter2> Logger
+@inject PersistentComponentState ApplicationState
+
+<PageTitle>Counter</PageTitle>
+
+<h1>Counter</h1>
+
+<p role="status">Current count: @currentCount</p>
+
+<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>
 
 @code {
-    private WeatherForecast[] forecasts = Array.Empty<WeatherForecast>();
+    private int currentCount;
+    private Random r = new Random();
     private PersistingComponentStateSubscription persistingSubscription;
 
-    protected override async Task OnInitializedAsync()
+    protected override void OnInitialized()
     {
-        persistingSubscription = 
-            ApplicationState.RegisterOnPersisting(PersistForecasts);
+        persistingSubscription =
+            ApplicationState.RegisterOnPersisting(PersistCount);
 
-        if (!ApplicationState.TryTakeFromJson<WeatherForecast[]>(
-            "fetchdata", out var restored))
+        if (!ApplicationState.TryTakeFromJson<int>(
+            "count", out var restoredCount))
         {
-            forecasts = 
-                await WeatherForecastService.GetForecastAsync(DateOnly.FromDateTime(DateTime.Now));
+            currentCount = r.Next(100);
+            Logger.LogInformation("currentCount set to {Count}", currentCount);
         }
         else
         {
-            forecasts = restored!;
+            currentCount = restoredCount!;
+            Logger.LogInformation("currentCount restored to {Count}", currentCount);
         }
     }
 
-    private Task PersistForecasts()
+    private Task PersistCount()
     {
-        ApplicationState.PersistAsJson("fetchdata", forecasts);
+        ApplicationState.PersistAsJson("count", currentCount);
 
         return Task.CompletedTask;
     }
@@ -117,14 +177,26 @@ else
     {
         persistingSubscription.Dispose();
     }
+
+    private void IncrementCount()
+    {
+        currentCount++;
+    }
 }
 ```
 
+When the component executes, `currentCount` is only set once during prerendering. The value is restored when the component is rerendered after prerendering:
+
+> :::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":::
 
+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.
 
-Add the Tag Helper's tag, `<persist-component-state />`, inside the closing `</body>` tag.
+For components embedded into a page or view of a Razor Pages or MVC app, you must add the [Persist Component State Tag Helper](xref:mvc/views/tag-helpers/builtin-th/persist-component-state-tag-helper) with the `<persist-component-state />` HTML tag inside the closing `</body>` tag of the app's layout. **This is only required for Razor Pages and MVC apps.** For more information, see <xref:mvc/views/tag-helpers/builtin-th/persist-component-state-tag-helper>.
 
-`Pages/_Host.cshtml`:
+`Pages/Shared/_Layout.cshtml`:
 
 ```cshtml
 <body>
@@ -134,11 +206,6 @@ Add the Tag Helper's tag, `<persist-component-state />`, inside the closing `</b
 </body>
 ```
 
-
-
-
-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.
-
 ## Prerendering guidance
 
 Prerendering guidance is organized in the Blazor documentation by subject matter. The following links cover all of the prerendering guidance throughout the documentation set by subject:

From ed31af02b4f4b47a8c1fc08354da6dc5870d2560 Mon Sep 17 00:00:00 2001
From: guardrex <1622880+guardrex@users.noreply.github.com>
Date: Fri, 29 Sep 2023 12:57:58 -0400
Subject: [PATCH 11/15] Updates

---
 aspnetcore/blazor/components/prerendering.md | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/aspnetcore/blazor/components/prerendering.md b/aspnetcore/blazor/components/prerendering.md
index b51fa1f45191..1961c1a70b82 100644
--- a/aspnetcore/blazor/components/prerendering.md
+++ b/aspnetcore/blazor/components/prerendering.md
@@ -23,11 +23,6 @@ This article explains Razor component prerendering scenarios for server-rendered
   
 Prerendering can improve [Search Engine Optimization (SEO)](https://developer.mozilla.org/docs/Glossary/SEO) by rendering content for the initial HTTP response that search engines can use to calculate page rank.
 
-<!-- UPDATE 8.0 Remove WARNING at RC2 -->
-
-> [!WARNING]
-> Guidance in this document pertains to the ***Release Candidate 2*** of .NET 8, which is targeted for release on October 10.
-
 ## Persist prerendered state
 
 Without persisting prerendered state, state used during prerendering is lost and must be recreated when the app is fully loaded. If any state is setup asynchronously, the UI may flicker as the prerendered UI is replaced with temporary placeholders and then fully rendered again.
@@ -38,7 +33,7 @@ Consider the following `PrerenderedCounter1` component, which is a version of th
 
 ```razor
 @page "/prerendered-counter-1"
-@attribute [RenderModeInteractiveServer]
+@attribute [RenderModeServer]
 @inject ILogger<PrerenderedCounter1> Logger
 
 <PageTitle>Counter</PageTitle>
@@ -130,7 +125,7 @@ The following counter component example persists counter state during prerenderi
 
 ```razor
 @page "/prerendered-counter-2"
-@attribute [RenderModeInteractiveServer]
+@attribute [RenderModeServer]
 @implements IDisposable
 @inject ILogger<PrerenderedCounter2> Logger
 @inject PersistentComponentState ApplicationState

From 56f86b4daa5f7689e096756dfe73bde335ea22cb Mon Sep 17 00:00:00 2001
From: guardrex <1622880+guardrex@users.noreply.github.com>
Date: Fri, 29 Sep 2023 13:41:39 -0400
Subject: [PATCH 12/15] Updates

---
 aspnetcore/blazor/components/integration.md | 44 ++++++++++++++++++++-
 1 file changed, 43 insertions(+), 1 deletion(-)

diff --git a/aspnetcore/blazor/components/integration.md b/aspnetcore/blazor/components/integration.md
index 1f136e419d61..4f692749ce21 100644
--- a/aspnetcore/blazor/components/integration.md
+++ b/aspnetcore/blazor/components/integration.md
@@ -85,20 +85,38 @@ In the project's layout file (`Pages/Shared/_Layout.cshtml` in Razor Pages apps
 
 In the `Program` file where services are registered before the line that builds the app (`builder.Build()`), add services for Razor components and services to support rendering interactive server components:
 
+```csharp
+builder.Services.AddRazorComponents()
+    .AddServerComponents();
+```
+
+<!-- UPDATE 8.0 RC2
+
 ```csharp
 builder.Services.AddRazorComponents()
     .AddInteractiveServerComponents();
 ```
 
+-->
+
 <!-- UPDATE 8.0 Update API cross-link -->
 
 In the `Program` file immediately after the call to map Razor Pages (<xref:Microsoft.AspNetCore.Builder.RazorPagesEndpointRouteBuilderExtensions.MapRazorPages%2A>), call <xref:Microsoft.AspNetCore.Builder.RazorComponentsEndpointRouteBuilderExtensions.MapRazorComponents%2A> in the middleware processing pipeline to discover available components and specify the root component for the app, which by default is the `App` component (`App.razor`). Chain a call to `AddInteractiveServerRenderMode` <!-- <xref:Microsoft.AspNetCore.Builder.RazorComponentsEndpointConventionBuilder.AddInteractiveServerRenderMode%2A> --> to configure the Server render mode for the app:
 
+```csharp
+app.MapRazorComponents<App>()
+    .AddServerRenderMode();
+```
+
+<!-- UPDATE 8.0 RC2
+
 ```csharp
 app.MapRazorComponents<App>()
     .AddInteractiveServerRenderMode();
 ```
 
+-->
+
 > [!NOTE]
 > If the app hasn't already been updated to include Antiforgery Middleware, add the following line after <xref:Microsoft.AspNetCore.Builder.AuthorizationAppBuilderExtensions.UseAuthorization%2A> is called:
 >
@@ -380,20 +398,38 @@ Add an `App` component to the `Components` folder with the following content.
 
 In the `Program` file where services are registered before the line that builds the app (`builder.Build()`), add services for Razor components and services to support rendering interactive server components:
 
+```csharp
+builder.Services.AddRazorComponents()
+    .AddServerComponents();
+```
+
+<!-- UPDATE 8.0 RC2
+
 ```csharp
 builder.Services.AddRazorComponents()
     .AddInteractiveServerComponents();
 ```
 
+-->
+
 <!-- UPDATE 8.0 Update API cross-link -->
 
 In the `Program` file immediately after the call to map Razor Pages (<xref:Microsoft.AspNetCore.Builder.RazorPagesEndpointRouteBuilderExtensions.MapRazorPages%2A>) or map controller routes (<xref:Microsoft.AspNetCore.Builder.ControllerEndpointRouteBuilderExtensions.MapControllerRoute%2A>), call <xref:Microsoft.AspNetCore.Builder.RazorComponentsEndpointRouteBuilderExtensions.MapRazorComponents%2A> in the middleware processing pipeline to discover available components and specify the root component for the app, which by default is the `App` component (`App.razor`). Chain a call to `AddInteractiveServerRenderMode` <!-- <xref:Microsoft.AspNetCore.Builder.RazorComponentsEndpointConventionBuilder.AddInteractiveServerRenderMode%2A> --> to configure the Server render mode for the app:
 
+```csharp
+app.MapRazorComponents<App>()
+    .AddServerRenderMode();
+```
+
+<!-- UPDATE 8.0 RC2
+
 ```csharp
 app.MapRazorComponents<App>()
     .AddInteractiveServerRenderMode();
 ```
 
+-->
+
 > [!NOTE]
 > If the app hasn't already been updated to include Antiforgery Middleware, add the following line after <xref:Microsoft.AspNetCore.Builder.AuthorizationAppBuilderExtensions.UseAuthorization%2A> is called:
 >
@@ -407,7 +443,7 @@ Create a `Pages` folder in the `Components` folder for routable components. The
 
 ```razor
 @page "/counter"
-@attribute [RenderModeInteractiveServer]
+@attribute [RenderModeServer]
 
 <PageTitle>Counter</PageTitle>
 
@@ -427,6 +463,12 @@ Create a `Pages` folder in the `Components` folder for routable components. The
 }
 ```
 
+<!-- UPDATE 8.0 RC2
+
+@attribute [RenderModeInteractiveServer]
+
+-->
+
 Run the project and navigate to the routable `Counter` component at `/counter`.
 
 For more information on namespaces, see the [Component namespaces](#component-namespaces) section.

From 560b54249addb0de60ee908f46b9d921b19bcd88 Mon Sep 17 00:00:00 2001
From: guardrex <1622880+guardrex@users.noreply.github.com>
Date: Fri, 29 Sep 2023 13:45:41 -0400
Subject: [PATCH 13/15] Updates

---
 aspnetcore/blazor/components/integration.md  |  5 -----
 aspnetcore/blazor/components/prerendering.md | 12 ++++++++++++
 2 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/aspnetcore/blazor/components/integration.md b/aspnetcore/blazor/components/integration.md
index 4f692749ce21..a4ef5bb7ecaf 100644
--- a/aspnetcore/blazor/components/integration.md
+++ b/aspnetcore/blazor/components/integration.md
@@ -14,11 +14,6 @@ uid: blazor/components/integration
 [!INCLUDE[](~/includes/not-latest-version.md)]
 -->
 
-<!-- UPDATE 8.0 Remove WARNING at RC2 -->
-
-> [!WARNING]
-> Guidance in this document pertains to the ***Release Candidate 2*** of .NET 8, which is targeted for release on October 10.
-
 This article explains Razor component integration scenarios for ASP.NET Core apps, including prerendering of Razor components on the server.
 
 Razor components can be integrated into Razor Pages and MVC apps. When the page or view is rendered, components can be prerendered at the same time. Prerendering can improve [Search Engine Optimization (SEO)](https://developer.mozilla.org/docs/Glossary/SEO) by rendering content for the initial HTTP response that search engines can use to calculate page rank.
diff --git a/aspnetcore/blazor/components/prerendering.md b/aspnetcore/blazor/components/prerendering.md
index 1961c1a70b82..151cf77ed999 100644
--- a/aspnetcore/blazor/components/prerendering.md
+++ b/aspnetcore/blazor/components/prerendering.md
@@ -61,6 +61,12 @@ Consider the following `PrerenderedCounter1` component, which is a version of th
 }
 ```
 
+<!-- UPDATE 8.0 RC2
+
+@attribute [RenderModeInteractiveServer]
+
+-->
+
 Run the app and inspect logging from the component:
 
 > :::no-loc text="info: BlazorSample.Components.Pages.PrerenderedCounter1[0]":::  
@@ -180,6 +186,12 @@ The following counter component example persists counter state during prerenderi
 }
 ```
 
+<!-- UPDATE 8.0 RC2
+
+@attribute [RenderModeInteractiveServer]
+
+-->
+
 When the component executes, `currentCount` is only set once during prerendering. The value is restored when the component is rerendered after prerendering:
 
 > :::no-loc text="info: BlazorSample.Components.Pages.PrerenderedCounter2[0]":::  

From c1c743c9b2c2cbd15f0377692c22fb8c928e1b26 Mon Sep 17 00:00:00 2001
From: guardrex <1622880+guardrex@users.noreply.github.com>
Date: Fri, 29 Sep 2023 14:26:21 -0400
Subject: [PATCH 14/15] Updates

---
 aspnetcore/blazor/components/integration.md | 28 +++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/aspnetcore/blazor/components/integration.md b/aspnetcore/blazor/components/integration.md
index a4ef5bb7ecaf..7310333a7da5 100644
--- a/aspnetcore/blazor/components/integration.md
+++ b/aspnetcore/blazor/components/integration.md
@@ -468,6 +468,34 @@ Run the project and navigate to the routable `Counter` component at `/counter`.
 
 For more information on namespaces, see the [Component namespaces](#component-namespaces) section.
 
+## Return a `RazorComponentResult` from an MVC controller action
+
+An MVC controller action can return a component with `RazorComponentResult`.
+
+`Components/Welcome.razor`:
+
+```razor
+<PageTitle>Welcome!</PageTitle>
+
+<h1>Welcome!</h1>
+
+<p>@Message</p>
+
+@code {
+    [Parameter]
+    public string? Message { get; set; }
+}
+```
+
+In a controller:
+
+```csharp
+public IResult GetWelcomeComponent()
+{
+    return new RazorComponentResult<Welcome>(new { Message = "Hello, world!" });
+}
+```
+
 ## Component namespaces
 
 When using a custom folder to hold the project's Razor components, add the namespace representing the folder to either the page/view or to the `_ViewImports.cshtml` file. In the following example:

From 8e4f88391f07806994ed1f4ae01a774b3063029b Mon Sep 17 00:00:00 2001
From: guardrex <1622880+guardrex@users.noreply.github.com>
Date: Mon, 2 Oct 2023 08:39:45 -0400
Subject: [PATCH 15/15] Updates

---
 aspnetcore/blazor/components/integration.md   | 80 ++++++++++++++-----
 .../prerendering-and-integration.md           |  8 +-
 aspnetcore/blazor/components/prerendering.md  | 20 ++---
 aspnetcore/blazor/file-downloads.md           |  2 +-
 aspnetcore/blazor/fundamentals/signalr.md     | 10 +--
 .../security/server/threat-mitigation.md      |  6 +-
 .../built-in/component-tag-helper.md          | 34 +++++---
 .../built-in/persist-component-state.md       |  3 +
 8 files changed, 110 insertions(+), 53 deletions(-)

diff --git a/aspnetcore/blazor/components/integration.md b/aspnetcore/blazor/components/integration.md
index 7310333a7da5..fa87c826bbd8 100644
--- a/aspnetcore/blazor/components/integration.md
+++ b/aspnetcore/blazor/components/integration.md
@@ -33,7 +33,7 @@ When server prerendering is used and the page or view renders:
 * The initial component state used for prerendering is lost.
 * New component state is created when the SignalR connection is established.
 
-For more information on rendering modes, including non-interactive static component rendering, see <xref:mvc/views/tag-helpers/builtin-th/component-tag-helper>. To save the state of Razor components rendered in a page or view, see <xref:mvc/views/tag-helpers/builtin-th/persist-component-state-tag-helper>.
+For more information on rendering modes, including non-interactive static component rendering, see <xref:mvc/views/tag-helpers/builtin-th/component-tag-helper>. To save the state of prerendered Razor components, see <xref:mvc/views/tag-helpers/builtin-th/persist-component-state-tag-helper>.
 
 Add a `Components` folder to the root folder of the project.
 
@@ -55,7 +55,7 @@ Add an imports file to the `Components` folder with the following content. Chang
 
 In the project's layout file (`Pages/Shared/_Layout.cshtml` in Razor Pages apps or `Views/Shared/_Layout.cshtml` in MVC apps):
 
-* Add the following `<base>` tag and <xref:Microsoft.AspNetCore.Components.Web.HeadOutlet> component via a [Component Tag Helper](xref:mvc/views/tag-helpers/builtin-th/component-tag-helper) to the `<head>` element:
+* Add the following `<base>` tag and [Component Tag Helper](xref:mvc/views/tag-helpers/builtin-th/component-tag-helper) for a <xref:Microsoft.AspNetCore.Components.Web.HeadOutlet> component to the `<head>` markup:
 
   ```cshtml
   <base href="~/" />
@@ -73,12 +73,14 @@ In the project's layout file (`Pages/Shared/_Layout.cshtml` in Razor Pages apps
   <script src="_framework/blazor.web.js"></script>
   ```
 
-  The framework adds the `blazor.web.js` script to the app. There's no need to manually add a `blazor.web.js` script file to the app.
+  There's no need to manually add a `blazor.web.js` script to the app because the Blazor framework adds the `blazor.web.js` script to the app.
 
 > [!NOTE]
 > Typically, the layout loads via a `_ViewStart.cshtml` file.
 
-In the `Program` file where services are registered before the line that builds the app (`builder.Build()`), add services for Razor components and services to support rendering interactive server components:
+Where services are registered, add services for Razor components and services to support rendering interactive server components.
+
+In the `Program` file before the line that builds the app (`builder.Build()`):
 
 ```csharp
 builder.Services.AddRazorComponents()
@@ -94,9 +96,11 @@ builder.Services.AddRazorComponents()
 
 -->
 
+For more information on adding support for server and WebAssembly components, see <xref:blazor/components/render-modes>.
+
 <!-- UPDATE 8.0 Update API cross-link -->
 
-In the `Program` file immediately after the call to map Razor Pages (<xref:Microsoft.AspNetCore.Builder.RazorPagesEndpointRouteBuilderExtensions.MapRazorPages%2A>), call <xref:Microsoft.AspNetCore.Builder.RazorComponentsEndpointRouteBuilderExtensions.MapRazorComponents%2A> in the middleware processing pipeline to discover available components and specify the root component for the app, which by default is the `App` component (`App.razor`). Chain a call to `AddInteractiveServerRenderMode` <!-- <xref:Microsoft.AspNetCore.Builder.RazorComponentsEndpointConventionBuilder.AddInteractiveServerRenderMode%2A> --> to configure the Server render mode for the app:
+In the `Program` file immediately after the call to map Razor Pages (<xref:Microsoft.AspNetCore.Builder.RazorPagesEndpointRouteBuilderExtensions.MapRazorPages%2A>), call <xref:Microsoft.AspNetCore.Builder.RazorComponentsEndpointRouteBuilderExtensions.MapRazorComponents%2A> to discover available components and specify the app's root component. By default, the app's root component is the `App` component (`App.razor`). Chain a call to `AddInteractiveServerRenderMode` <!-- <xref:Microsoft.AspNetCore.Builder.RazorComponentsEndpointConventionBuilder.AddInteractiveServerRenderMode%2A> --> to configure the Server render mode for the app:
 
 ```csharp
 app.MapRazorComponents<App>()
@@ -176,11 +180,16 @@ In the project's `Index` view of an MVC app, add the `EmbeddedCounter` component
 
 Use the following guidance to integrate routable Razor components into an existing Razor Pages or MVC app.
 
+The guidance in this section assumes:
+
+* The title of the app is `Blazor Sample`.
+* The namespace of the app is `BlazorSample`.
+
 To support routable Razor components:
 
 Add a `Components` folder to the root folder of the project.
 
-Add an imports file to the `Components` folder with the following content. Change the `{APP NAMESPACE}` placeholder to the namespace of the project.
+Add an imports file to the `Components` folder with the following content.
 
 `Components/_Imports.razor`:
 
@@ -196,9 +205,16 @@ Add an imports file to the `Components` folder with the following content. Chang
 @using {APP NAMESPACE}.Components
 ```
 
+Change the `{APP NAMESPACE}` placeholder to the namespace of the project. For example:
+
+```razor
+@using BlazorSample
+@using BlazorSample.Components
+```
+
 Add a `Layout` folder to the `Components` folder.
 
-Add a footer component and stylesheet.
+Add a footer component and stylesheet to the `Layout` folder.
 
 `Components/Layout/Footer.razor`:
 
@@ -210,7 +226,11 @@ Add a footer component and stylesheet.
 </footer>
 ```
 
-In the preceding markup, set the `{APP TITLE}` placeholder to the title of the app.
+In the preceding markup, set the `{APP TITLE}` placeholder to the title of the app. For example:
+
+```html
+&copy; 2023 - Blazor Sample - <a href="/privacy">Privacy</a>
+```
 
 `Components/Layout/Footer.razor.css`:
 
@@ -224,7 +244,7 @@ line-height: 60px;
 }
 ```
 
-Add a navigation menu component.
+Add a navigation menu component to the `Layout` folder.
 
 `Components/Layout/NavMenu.razor`:
 
@@ -252,7 +272,11 @@ Add a navigation menu component.
 </nav>
 ```
 
-In the preceding markup, set the `{APP TITLE}` placeholder to the title of the app.
+In the preceding markup, set the `{APP TITLE}` placeholder to the title of the app. For example:
+
+```html
+<a class="navbar-brand" href="/">Blazor Sample</a>
+```
 
 `Components/Layout/NavMenu.razor.css`:
 
@@ -297,7 +321,7 @@ button.accept-policy {
 }
    ```
 
-Add a main layout component and stylesheet.
+Add a main layout component and stylesheet to the `Layout` folder.
 
 `Components/Layout/MainLayout.razor`:
 
@@ -385,13 +409,23 @@ Add an `App` component to the `Components` folder with the following content.
 </html>
 ```
 
-> [!IMPORTANT]
-> The page title and stylesheet of routable components doesn't currently flow from the app and must be set manually:
->
-> * For the `{APP TITLE}` placeholder in the `<title>` element, set the app title.
-> * For the `{APP NAMESPACE}` placeholder in the stylesheet `<link>` element, set the app's namespace.
+In the preceding code update the app title and stylesheet file name:
 
-In the `Program` file where services are registered before the line that builds the app (`builder.Build()`), add services for Razor components and services to support rendering interactive server components:
+* For the `{APP TITLE}` placeholder in the `<title>` element, set the app's title. For example:
+
+  ```html
+  <title>Blazor Sample</title>
+  ```
+
+* For the `{APP NAMESPACE}` placeholder in the stylesheet `<link>` element, set the app's namespace. For example:
+
+  ```html
+  <link rel="stylesheet" href="/BlazorSample.styles.css" />
+  ```
+
+Where services are registered, add services for Razor components and services to support rendering interactive server components.
+
+In the `Program` file before the line that builds the app (`builder.Build()`):
 
 ```csharp
 builder.Services.AddRazorComponents()
@@ -407,9 +441,11 @@ builder.Services.AddRazorComponents()
 
 -->
 
+For more information on adding support for server and WebAssembly components, see <xref:blazor/components/render-modes>.
+
 <!-- UPDATE 8.0 Update API cross-link -->
 
-In the `Program` file immediately after the call to map Razor Pages (<xref:Microsoft.AspNetCore.Builder.RazorPagesEndpointRouteBuilderExtensions.MapRazorPages%2A>) or map controller routes (<xref:Microsoft.AspNetCore.Builder.ControllerEndpointRouteBuilderExtensions.MapControllerRoute%2A>), call <xref:Microsoft.AspNetCore.Builder.RazorComponentsEndpointRouteBuilderExtensions.MapRazorComponents%2A> in the middleware processing pipeline to discover available components and specify the root component for the app, which by default is the `App` component (`App.razor`). Chain a call to `AddInteractiveServerRenderMode` <!-- <xref:Microsoft.AspNetCore.Builder.RazorComponentsEndpointConventionBuilder.AddInteractiveServerRenderMode%2A> --> to configure the Server render mode for the app:
+In the `Program` file immediately after the call to map Razor Pages (<xref:Microsoft.AspNetCore.Builder.RazorPagesEndpointRouteBuilderExtensions.MapRazorPages%2A>), call <xref:Microsoft.AspNetCore.Builder.RazorComponentsEndpointRouteBuilderExtensions.MapRazorComponents%2A> to discover available components and specify the app's root component. By default, the app's root component is the `App` component (`App.razor`). Chain a call to `AddInteractiveServerRenderMode` <!-- <xref:Microsoft.AspNetCore.Builder.RazorComponentsEndpointConventionBuilder.AddInteractiveServerRenderMode%2A> --> to configure the Server render mode for the app:
 
 ```csharp
 app.MapRazorComponents<App>()
@@ -432,7 +468,7 @@ app.MapRazorComponents<App>()
 > app.UseAntiforgery();
 > ```
 
-Create a `Pages` folder in the `Components` folder for routable components. The following example is a `RoutableCounter` component based on the `Counter` component in the Blazor project templates.
+Create a `Pages` folder in the `Components` folder for routable components. The following example is a `Counter` component based on the `Counter` component in the Blazor project templates.
 
 `Components/Pages/Counter.razor`:
 
@@ -507,6 +543,12 @@ When using a custom folder to hold the project's Razor components, add the names
 @using {APP NAMESPACE}.Components
 ```
 
+For example:
+
+```cshtml
+@using BlazorSample.Components
+```
+
 The `_ViewImports.cshtml` file is located in the `Pages` folder of a Razor Pages app or the `Views` folder of an MVC app.
 
 For more information, see <xref:blazor/components/index#class-name-and-namespace>.
diff --git a/aspnetcore/blazor/components/prerendering-and-integration.md b/aspnetcore/blazor/components/prerendering-and-integration.md
index edac61c0eb92..0eeb6c978156 100644
--- a/aspnetcore/blazor/components/prerendering-and-integration.md
+++ b/aspnetcore/blazor/components/prerendering-and-integration.md
@@ -952,7 +952,7 @@ A large prerendered state size may exceed the SignalR circuit message size limit
 To resolve the problem, use ***either*** of the following approaches:
 
 * Reduce the amount of data that you are putting into the prerendered state.
-* Increase the [SignalR message size limit](xref:blazor/fundamentals/signalr#server-side-circuit-handler-options). ***WARNING***: Increasing the limit may increase the risk of Denial of service (DoS) attacks.
+* Increase the [SignalR message size limit](xref:blazor/fundamentals/signalr#server-side-circuit-handler-options). ***WARNING***: Increasing the limit may increase the risk of Denial of Service (DoS) attacks.
 
 ## Additional Blazor Server resources
 
@@ -1895,7 +1895,7 @@ A large prerendered state size may exceed the SignalR circuit message size limit
 To resolve the problem, use ***either*** of the following approaches:
 
 * Reduce the amount of data that you are putting into the prerendered state.
-* Increase the [SignalR message size limit](xref:blazor/fundamentals/signalr#server-side-circuit-handler-options). ***WARNING***: Increasing the limit may increase the risk of Denial of service (DoS) attacks.
+* Increase the [SignalR message size limit](xref:blazor/fundamentals/signalr#server-side-circuit-handler-options). ***WARNING***: Increasing the limit may increase the risk of Denial of Service (DoS) attacks.
 
 ## Additional Blazor Server resources
 
@@ -2601,7 +2601,7 @@ A large prerendered state size may exceed the SignalR circuit message size limit
 To resolve the problem, use ***either*** of the following approaches:
 
 * Reduce the amount of data that you are putting into the prerendered state.
-* Increase the [SignalR message size limit](xref:blazor/fundamentals/signalr#server-side-circuit-handler-options). ***WARNING***: Increasing the limit may increase the risk of Denial of service (DoS) attacks.
+* Increase the [SignalR message size limit](xref:blazor/fundamentals/signalr#server-side-circuit-handler-options). ***WARNING***: Increasing the limit may increase the risk of Denial of Service (DoS) attacks.
 
 ## Additional Blazor Server resources
 
@@ -3041,7 +3041,7 @@ A large prerendered state size may exceed the SignalR circuit message size limit
 To resolve the problem, use ***either*** of the following approaches:
 
 * Reduce the amount of data that you are putting into the prerendered state.
-* Increase the [SignalR message size limit](xref:blazor/fundamentals/signalr#server-side-circuit-handler-options). ***WARNING***: Increasing the limit may increase the risk of Denial of service (DoS) attacks.
+* Increase the [SignalR message size limit](xref:blazor/fundamentals/signalr#server-side-circuit-handler-options). ***WARNING***: Increasing the limit may increase the risk of Denial of Service (DoS) attacks.
 
 ## Additional Blazor Server resources
 
diff --git a/aspnetcore/blazor/components/prerendering.md b/aspnetcore/blazor/components/prerendering.md
index 151cf77ed999..bd5bf566d449 100644
--- a/aspnetcore/blazor/components/prerendering.md
+++ b/aspnetcore/blazor/components/prerendering.md
@@ -25,9 +25,9 @@ Prerendering can improve [Search Engine Optimization (SEO)](https://developer.mo
 
 ## Persist prerendered state
 
-Without persisting prerendered state, state used during prerendering is lost and must be recreated when the app is fully loaded. If any state is setup asynchronously, the UI may flicker as the prerendered UI is replaced with temporary placeholders and then fully rendered again.
+Without persisting prerendered state, state used during prerendering is lost and must be recreated when the app is fully loaded. If any state is created asynchronously, the UI may flicker as the prerendered UI is replaced when the component is rerendered.
 
-Consider the following `PrerenderedCounter1` component, which is a version of the `Counter` component found in apps created from the Blazor project template and that doesn't preserve the initial count (`currentCount`) during prerendering. The component sets an initial random counter value during prerendering. After the SignalR connection to the client is established, the component rerenders, and the initial count value is replaced when `OnInitialized` executes a second time.
+Consider the following `PrerenderedCounter1` counter component. The component sets an initial random counter value during prerendering in `OnInitialized`. After the SignalR connection to the client is established, the component rerenders, and the initial count value is replaced when `OnInitialized` executes a second time.
 
 `Components/Pages/PrerenderedCounter1.razor`:
 
@@ -36,9 +36,9 @@ Consider the following `PrerenderedCounter1` component, which is a version of th
 @attribute [RenderModeServer]
 @inject ILogger<PrerenderedCounter1> Logger
 
-<PageTitle>Counter</PageTitle>
+<PageTitle>Prerendered Counter 1</PageTitle>
 
-<h1>Counter</h1>
+<h1>Prerendered Counter 1</h1>
 
 <p role="status">Current count: @currentCount</p>
 
@@ -76,11 +76,11 @@ Run the app and inspect logging from the component:
 
 The first logged count occurs during prerendering. The count is set again after prerendering when the component is rerendered. There's also a flicker in the UI when the count updates from 41 to 92.
 
-To solve this problem, Blazor supports persisting state in a prerendered page using the <xref:Microsoft.AspNetCore.Components.PersistentComponentState> service (and for components embedded into pages or views of Razor Pages or MVC apps, the [Persist Component State Tag Helper](xref:mvc/views/tag-helpers/builtin-th/persist-component-state-tag-helper)).
+To retain the initial value of the counter during prerendering, Blazor supports persisting state in a prerendered page using the <xref:Microsoft.AspNetCore.Components.PersistentComponentState> service (and for components embedded into pages or views of Razor Pages or MVC apps, the [Persist Component State Tag Helper](xref:mvc/views/tag-helpers/builtin-th/persist-component-state-tag-helper)).
 
-To preserve prerendered state, decide what state to persist using the <xref:Microsoft.AspNetCore.Components.PersistentComponentState> service. [`PersistentComponentState.RegisterOnPersisting`](xref:Microsoft.AspNetCore.Components.PersistentComponentState.RegisterOnPersisting%2A) registers a callback to persist the component state before the app is paused. The state is retrieved when the application resumes.
+To preserve prerendered state, decide what state to persist using the <xref:Microsoft.AspNetCore.Components.PersistentComponentState> service. [`PersistentComponentState.RegisterOnPersisting`](xref:Microsoft.AspNetCore.Components.PersistentComponentState.RegisterOnPersisting%2A) registers a callback to persist the component state before the app is paused. The state is retrieved when the app resumes.
 
-In following example demonstrates the general pattern:
+The following example demonstrates the general pattern:
 
 * The `{TYPE}` placeholder represents the type of data to persist.
 * The `{TOKEN}` placeholder is a state identifier string.
@@ -136,9 +136,9 @@ The following counter component example persists counter state during prerenderi
 @inject ILogger<PrerenderedCounter2> Logger
 @inject PersistentComponentState ApplicationState
 
-<PageTitle>Counter</PageTitle>
+<PageTitle>Prerendered Counter 2</PageTitle>
 
-<h1>Counter</h1>
+<h1>Prerendered Counter 2</h1>
 
 <p role="status">Current count: @currentCount</p>
 
@@ -192,7 +192,7 @@ 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 after prerendering:
+When the component executes, `currentCount` is only set once during prerendering. The value is restored when the component is rerendered:
 
 > :::no-loc text="info: BlazorSample.Components.Pages.PrerenderedCounter2[0]":::  
 > :::no-loc text="      currentCount set to 96":::  
diff --git a/aspnetcore/blazor/file-downloads.md b/aspnetcore/blazor/file-downloads.md
index cb21c0b48714..8191e6b8c0d8 100644
--- a/aspnetcore/blazor/file-downloads.md
+++ b/aspnetcore/blazor/file-downloads.md
@@ -30,7 +30,7 @@ When downloading files from a different origin than the app, Cross-Origin Resour
 
 ## Security considerations
 
-Use caution when providing users with the ability to download files from a server. Attackers may execute [denial of service (DOS)](/windows-hardware/drivers/ifs/denial-of-service) attacks, [API exploitation attacks](https://developer.mozilla.org/docs/Web/HTML/Element/a#security_and_privacy), or attempt to compromise networks and servers in other ways.
+Use caution when providing users with the ability to download files from a server. Attackers may execute [Denial of Service (DoS)](/windows-hardware/drivers/ifs/denial-of-service) attacks, [API exploitation attacks](https://developer.mozilla.org/docs/Web/HTML/Element/a#security_and_privacy), or attempt to compromise networks and servers in other ways.
 
 Security steps that reduce the likelihood of a successful attack are:
 
diff --git a/aspnetcore/blazor/fundamentals/signalr.md b/aspnetcore/blazor/fundamentals/signalr.md
index e42c7bd4bdfc..5d860760117d 100644
--- a/aspnetcore/blazor/fundamentals/signalr.md
+++ b/aspnetcore/blazor/fundamentals/signalr.md
@@ -115,7 +115,7 @@ A large prerendered state size may exceed the SignalR circuit message size limit
 To resolve the problem, use ***either*** of the following approaches:
 
 * Reduce the amount of data that you are putting into the prerendered state.
-* Increase the [SignalR message size limit](xref:blazor/fundamentals/signalr#server-side-circuit-handler-options). ***WARNING***: Increasing the limit may increase the risk of Denial of service (DoS) attacks.
+* Increase the [SignalR message size limit](xref:blazor/fundamentals/signalr#server-side-circuit-handler-options). ***WARNING***: Increasing the limit may increase the risk of Denial of Service (DoS) attacks.
 
 ## Additional client-side resources
 
@@ -271,7 +271,7 @@ services.AddServerSideBlazor().AddHubOptions(options =>
 :::moniker-end
 
 > [!WARNING]
-> The default value of <xref:Microsoft.AspNetCore.SignalR.HubOptions.MaximumReceiveMessageSize> is 32 KB. Increasing the value may increase the risk of [Denial of service (DoS) attacks](xref:blazor/security/server/threat-mitigation#denial-of-service-dos-attacks).
+> The default value of <xref:Microsoft.AspNetCore.SignalR.HubOptions.MaximumReceiveMessageSize> is 32 KB. Increasing the value may increase the risk of [Denial of Service (DoS) attacks](xref:blazor/security/server/threat-mitigation#denial-of-service-dos-attacks).
 
 For information on memory management, see <xref:blazor/host-and-deploy/server#memory-management>.
 
@@ -316,7 +316,7 @@ builder.Services.AddRazorComponents().AddServerComponents()
     .AddHubOptions(options => options.MaximumReceiveMessageSize = 64 * 1024);
 ```
 
-Increasing the SignalR incoming message size limit comes at the cost of requiring more server resources, and it increases the risk of [Denial of service (DoS) attacks](xref:blazor/security/server/threat-mitigation#denial-of-service-dos-attacks). Additionally, reading a large amount of content in to memory as strings or byte arrays can also result in allocations that work poorly with the garbage collector, resulting in additional performance penalties.
+Increasing the SignalR incoming message size limit comes at the cost of requiring more server resources, and it increases the risk of [Denial of Service (DoS) attacks](xref:blazor/security/server/threat-mitigation#denial-of-service-dos-attacks). Additionally, reading a large amount of content in to memory as strings or byte arrays can also result in allocations that work poorly with the garbage collector, resulting in additional performance penalties.
 
 A better option for reading large payloads is to send the content in smaller chunks and process the payload as a <xref:System.IO.Stream>. This can be used when reading large JavaScript (JS) interop JSON payloads or if JS interop data is available as raw bytes. For an example that demonstrates sending large binary payloads in server-side apps that uses techniques similar to the [`InputFile` component](xref:blazor/file-uploads), see the [Binary Submit sample app](https://github.com/aspnet/samples/tree/main/samples/aspnetcore/blazor/BinarySubmit) and the [Blazor `InputLargeTextArea` Component Sample](https://github.com/aspnet/samples/tree/main/samples/aspnetcore/blazor/InputLargeTextArea).
 
@@ -335,7 +335,7 @@ builder.Services.AddServerSideBlazor()
     .AddHubOptions(options => options.MaximumReceiveMessageSize = 64 * 1024);
 ```
 
-Increasing the SignalR incoming message size limit comes at the cost of requiring more server resources, and it increases the risk of [Denial of service (DoS) attacks](xref:blazor/security/server/threat-mitigation#denial-of-service-dos-attacks). Additionally, reading a large amount of content in to memory as strings or byte arrays can also result in allocations that work poorly with the garbage collector, resulting in additional performance penalties.
+Increasing the SignalR incoming message size limit comes at the cost of requiring more server resources, and it increases the risk of [Denial of Service (DoS) attacks](xref:blazor/security/server/threat-mitigation#denial-of-service-dos-attacks). Additionally, reading a large amount of content in to memory as strings or byte arrays can also result in allocations that work poorly with the garbage collector, resulting in additional performance penalties.
 
 A better option for reading large payloads is to send the content in smaller chunks and process the payload as a <xref:System.IO.Stream>. This can be used when reading large JavaScript (JS) interop JSON payloads or if JS interop data is available as raw bytes. For an example that demonstrates sending large binary payloads in Blazor Server that uses techniques similar to the [`InputFile` component](xref:blazor/file-uploads), see the [Binary Submit sample app](https://github.com/aspnet/samples/tree/main/samples/aspnetcore/blazor/BinarySubmit) and the [Blazor `InputLargeTextArea` Component Sample](https://github.com/aspnet/samples/tree/main/samples/aspnetcore/blazor/InputLargeTextArea).
 
@@ -354,7 +354,7 @@ services.AddServerSideBlazor()
     .AddHubOptions(options => options.MaximumReceiveMessageSize = 64 * 1024);
 ```
 
-Increasing the SignalR incoming message size limit comes at the cost of requiring more server resources, and it increases the risk of [Denial of service (DoS) attacks](xref:blazor/security/server/threat-mitigation#denial-of-service-dos-attacks). Additionally, reading a large amount of content in to memory as strings or byte arrays can also result in allocations that work poorly with the garbage collector, resulting in additional performance penalties.
+Increasing the SignalR incoming message size limit comes at the cost of requiring more server resources, and it increases the risk of [Denial of Service (DoS) attacks](xref:blazor/security/server/threat-mitigation#denial-of-service-dos-attacks). Additionally, reading a large amount of content in to memory as strings or byte arrays can also result in allocations that work poorly with the garbage collector, resulting in additional performance penalties.
 
 :::moniker-end
 
diff --git a/aspnetcore/blazor/security/server/threat-mitigation.md b/aspnetcore/blazor/security/server/threat-mitigation.md
index da854a9c369f..2bf79643ec61 100644
--- a/aspnetcore/blazor/security/server/threat-mitigation.md
+++ b/aspnetcore/blazor/security/server/threat-mitigation.md
@@ -43,7 +43,7 @@ Resource exhaustion can occur when a client interacts with the server and causes
 * [Memory](#memory)
 * [Client connections](#client-connections)
 
-Denial of service (DoS) attacks usually seek to exhaust an app or server's resources. However, resource exhaustion isn't necessarily the result of an attack on the system. For example, finite resources can be exhausted due to high user demand. DoS is covered further in the [Denial of service (DoS) attacks](#denial-of-service-dos-attacks) section.
+Denial of Service (DoS) attacks usually seek to exhaust an app or server's resources. However, resource exhaustion isn't necessarily the result of an attack on the system. For example, finite resources can be exhausted due to high user demand. DoS is covered further in the [DoS section](#denial-of-service-dos-attacks).
 
 Resources external to the Blazor framework, such as databases and file handles (used to read and write files), may also experience resource exhaustion. For more information, see <xref:fundamentals/best-practices>.
 
@@ -123,9 +123,9 @@ By default, there's no limit on the number of connections per user for an app. I
 
 :::moniker-end
 
-## Denial of service (DoS) attacks
+## Denial of Service (DoS) attacks
 
-[Denial of service (DoS) attacks](https://developer.mozilla.org/docs/Glossary/DOS_attack) involve a client causing the server to exhaust one or more of its resources making the app unavailable. Blazor apps include default limits and rely on other ASP.NET Core and SignalR limits that are set on <xref:Microsoft.AspNetCore.Components.Server.CircuitOptions> to protect against DoS attacks:
+[Denial of Service (DoS) attacks](https://developer.mozilla.org/docs/Glossary/DOS_attack) involve a client causing the server to exhaust one or more of its resources making the app unavailable. Blazor apps include default limits and rely on other ASP.NET Core and SignalR limits that are set on <xref:Microsoft.AspNetCore.Components.Server.CircuitOptions> to protect against DoS attacks:
 
 * <xref:Microsoft.AspNetCore.Components.Server.CircuitOptions.DisconnectedCircuitMaxRetained?displayProperty=nameWithType>
 * <xref:Microsoft.AspNetCore.Components.Server.CircuitOptions.DisconnectedCircuitRetentionPeriod?displayProperty=nameWithType>
diff --git a/aspnetcore/mvc/views/tag-helpers/built-in/component-tag-helper.md b/aspnetcore/mvc/views/tag-helpers/built-in/component-tag-helper.md
index 60d804bbca02..c4c3e232d3f1 100644
--- a/aspnetcore/mvc/views/tag-helpers/built-in/component-tag-helper.md
+++ b/aspnetcore/mvc/views/tag-helpers/built-in/component-tag-helper.md
@@ -125,7 +125,7 @@ The Component Tag Helper can also pass parameters to components. Consider the fo
     public int Size { get; set; } = 8;
 
     [Parameter]
-    public string Color { get; set; }
+    public string? Color { get; set; }
 
     protected override void OnInitialized()
     {
@@ -184,7 +184,7 @@ The Component Tag Helper can also pass parameters to components. Consider the fo
     public int Size { get; set; } = 8;
 
     [Parameter]
-    public string Color { get; set; }
+    public string? Color { get; set; }
 
     protected override void OnInitialized()
     {
@@ -255,13 +255,13 @@ public class MyClass
 ```razor
 <h2>ParameterComponent</h2>
 
-<p>Int: @MyObject.MyInt</p>
-<p>String: @MyObject.MyString</p>
+<p>Int: @MyObject?.MyInt</p>
+<p>String: @MyObject?.MyString</p>
 
 @code
 {
     [Parameter]
-    public MyClass MyObject { get; set; }
+    public MyClass? MyObject { get; set; }
 }
 ```
 
@@ -284,7 +284,7 @@ public class MyClass
     param-MyObject="@myObject" />
 ```
 
-The preceding example assumes that the `ParameterComponent` component is in the app's `Components`` folder. The placeholder `{APP ASSEMBLY}` is the app's assembly name (for example, `@using BlazorSample` and `@using BlazorSample.Components`). `MyClass` is in the app's namespace.
+The preceding example assumes that the `ParameterComponent` component is in the app's `Components` folder. The placeholder `{APP ASSEMBLY}` is the app's assembly name (for example, `@using BlazorSample` and `@using BlazorSample.Components`). `MyClass` is in the app's namespace.
 
 :::moniker-end
 
@@ -295,13 +295,13 @@ The preceding example assumes that the `ParameterComponent` component is in the
 ```razor
 <h2>ParameterComponent</h2>
 
-<p>Int: @MyObject.MyInt</p>
-<p>String: @MyObject.MyString</p>
+<p>Int: @MyObject?.MyInt</p>
+<p>String: @MyObject?.MyString</p>
 
 @code
 {
     [Parameter]
-    public MyClass MyObject { get; set; }
+    public MyClass? MyObject { get; set; }
 }
 ```
 
@@ -324,7 +324,7 @@ The preceding example assumes that the `ParameterComponent` component is in the
     param-MyObject="@myObject" />
 ```
 
-The preceding example assumes that the `ParameterComponent` component is in the app's `Shared`` folder. The placeholder `{APP ASSEMBLY}` is the app's assembly name (for example, `@using BlazorSample` and `@using BlazorSample.Shared`). `MyClass` is in the app's namespace.
+The preceding example assumes that the `ParameterComponent` component is in the app's `Shared` folder. The placeholder `{APP ASSEMBLY}` is the app's assembly name (for example, `@using BlazorSample` and `@using BlazorSample.Shared`). `MyClass` is in the app's namespace.
 
 :::moniker-end
 
@@ -332,6 +332,7 @@ The preceding example assumes that the `ParameterComponent` component is in the
 
 :::moniker range=">= aspnetcore-8.0"
 
+* <xref:mvc/views/tag-helpers/builtin-th/persist-component-state-tag-helper>
 * <xref:blazor/components/prerender>
 * <xref:Microsoft.AspNetCore.Mvc.TagHelpers.ComponentTagHelper>
 * <xref:mvc/views/tag-helpers/intro>
@@ -339,8 +340,19 @@ The preceding example assumes that the `ParameterComponent` component is in the
 
 :::moniker-end
 
-:::moniker range="< aspnetcore-8.0"
+:::moniker range=">= aspnetcore-6.0 < aspnetcore-8.0"
+
+* <xref:mvc/views/tag-helpers/builtin-th/persist-component-state-tag-helper>
+* <xref:blazor/components/prerendering-and-integration>
+* <xref:Microsoft.AspNetCore.Mvc.TagHelpers.ComponentTagHelper>
+* <xref:mvc/views/tag-helpers/intro>
+* <xref:blazor/components/index>
+
+:::moniker-end
+
+:::moniker range="< aspnetcore-6.0"
 
+* <xref:blazor/components/prerendering-and-integration>
 * <xref:Microsoft.AspNetCore.Mvc.TagHelpers.ComponentTagHelper>
 * <xref:mvc/views/tag-helpers/intro>
 * <xref:blazor/components/index>
diff --git a/aspnetcore/mvc/views/tag-helpers/built-in/persist-component-state.md b/aspnetcore/mvc/views/tag-helpers/built-in/persist-component-state.md
index 3e44594739ad..88f45aa72358 100644
--- a/aspnetcore/mvc/views/tag-helpers/built-in/persist-component-state.md
+++ b/aspnetcore/mvc/views/tag-helpers/built-in/persist-component-state.md
@@ -79,6 +79,7 @@ For more information and examples, see <xref:blazor/components/prerendering-and-
 
 :::moniker range=">= aspnetcore-8.0"
 
+* <xref:mvc/views/tag-helpers/builtin-th/component-tag-helper>
 * <xref:blazor/components/prerender>
 * <xref:Microsoft.AspNetCore.Mvc.TagHelpers.ComponentTagHelper>
 * <xref:mvc/views/tag-helpers/intro>
@@ -88,6 +89,8 @@ For more information and examples, see <xref:blazor/components/prerendering-and-
 
 :::moniker range="< aspnetcore-8.0"
 
+* <xref:mvc/views/tag-helpers/builtin-th/component-tag-helper>
+* <xref:blazor/components/prerendering-and-integration>
 * <xref:Microsoft.AspNetCore.Mvc.TagHelpers.ComponentTagHelper>
 * <xref:mvc/views/tag-helpers/intro>
 * <xref:blazor/components/index>
