Merge to Live

.github/workflows/quest-bulk.yml

@@ -1,8 +1,8 @@
 name: "bulk quest import"
 on:
   schedule:
-    - cron: '0 10 * * *' # UTC time, that's 5:00 am EST, 2:00 am PST.
-    - cron: '0 9 6 * *'  # This is the morning of the 6th.
+    - cron: '30 12 1-5,6-31 * *' # UTC time, that's 7:30 am EST, 4:30 am PST.
+    - cron: '30 12 6 * *'  # This is the morning of the 6th.
   workflow_dispatch:
     inputs:
       reason:
@@ -50,5 +50,5 @@ jobs:
           org: ${{ github.repository_owner }}
           repo: ${{ github.repository }}
           issue: '-1'
-          duration: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.duration || github.event.schedule == '0 9 6 * *' && -1 || 5 }}
+          duration: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.duration || github.event.schedule == '30 12 6 * *' && -1 || 5 }}
 

.github/workflows/quest.yml

@@ -46,7 +46,7 @@ jobs:
         uses: dotnet/docs-tools/actions/sequester@main
         env:
           ImportOptions__ApiKeys__GitHubToken: ${{ secrets.GITHUB_TOKEN }}
-          ImportOptions__ApiKeys__AzureAccessToken: ${{ steps.azure-oidc-auth.outputs.access-token }}
+          ImportOptions__ApiKeys__AzureAccessToken: ${{ steps.azure-oidc-auth.outputs.access-token }}s
           ImportOptions__ApiKeys__QuestKey: ${{ secrets.QUEST_KEY }}
           ImportOptions__ApiKeys__SequesterPrivateKey: ${{ secrets.SEQUESTER_PRIVATEKEY }}
           ImportOptions__ApiKeys__SequesterAppID: ${{ secrets.SEQUESTER_APPID }}
@@ -62,7 +62,7 @@ jobs:
         uses: dotnet/docs-tools/actions/sequester@main
         env:
           ImportOptions__ApiKeys__GitHubToken: ${{ secrets.GITHUB_TOKEN }}
-          ImportOptions__ApiKeys__AzureAccessToken: ${{ $AZURE_ACCESS_TOKEN }}
+          ImportOptions__ApiKeys__AzureAccessToken: ${{ steps.azure-oidc-auth.outputs.access-token }}
           ImportOptions__ApiKeys__QuestKey: ${{ secrets.QUEST_KEY }}
           ImportOptions__ApiKeys__SequesterPrivateKey: ${{ secrets.SEQUESTER_PRIVATEKEY }}
           ImportOptions__ApiKeys__SequesterAppID: ${{ secrets.SEQUESTER_APPID }}

aspnetcore/blazor/components/integration-hosted-webassembly.md

@@ -415,7 +415,7 @@ In `Pages/_Host.cshtml` of Blazor apps that are WebAssembly prerendered (`WebAss
 </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.
+Decide what state to persist using the <xref:Microsoft.AspNetCore.Components.PersistentComponentState> service. <xref:Microsoft.AspNetCore.Components.PersistentComponentState.RegisterOnPersisting%2A?displayProperty=nameWithType> registers a callback to persist the component state before the app is paused. The state is retrieved when the application resumes. Make the call at the end of initialization code in order to avoid a potential race condition during app shutdown.
 
 In the following example:
 
@@ -434,9 +434,6 @@ In the following example:
 
     protected override async Task OnInitializedAsync()
     {
-        persistingSubscription = 
-            ApplicationState.RegisterOnPersisting(PersistData);
-
         if (!ApplicationState.TryTakeFromJson<{TYPE}>(
             "{TOKEN}", out var restored))
         {
@@ -446,6 +443,9 @@ In the following example:
         {
             data = restored!;
         }
+
+        // Call at the end to avoid a potential race condition at app shutdown
+        persistingSubscription = ApplicationState.RegisterOnPersisting(PersistData);
     }
 
     private Task PersistData()
@@ -514,22 +514,22 @@ else
 
     protected override async Task OnInitializedAsync()
     {
-        persistingSubscription = 
-            ApplicationState.RegisterOnPersisting(PersistForecasts);
-
         if (!ApplicationState.TryTakeFromJson<WeatherForecast[]>(
             "fetchdata", out var restored))
         {
-            forecasts = 
-                await WeatherForecastService.GetForecastAsync(DateOnly.FromDateTime(DateTime.Now));
+            forecasts = await WeatherForecastService.GetForecastAsync(
+                DateOnly.FromDateTime(DateTime.Now));
         }
         else
         {
             forecasts = restored!;
         }
+
+        // Call at the end to avoid a potential race condition at app shutdown
+        persistingSubscription = ApplicationState.RegisterOnPersisting(PersistData);
     }
 
-    private Task PersistForecasts()
+    private Task PersistData()
     {
         ApplicationState.PersistAsJson("fetchdata", forecasts);
 
@@ -975,7 +975,7 @@ To solve these problems, Blazor supports persisting state in a prerendered page
 </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.
+Decide what state to persist using the <xref:Microsoft.AspNetCore.Components.PersistentComponentState> service. <xref:Microsoft.AspNetCore.Components.PersistentComponentState.RegisterOnPersisting%2A?displayProperty=nameWithType> registers a callback to persist the component state before the app is paused. The state is retrieved when the application resumes. Make the call at the end of initialization code in order to avoid a potential race condition during app shutdown.
 
 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.
 
@@ -1029,9 +1029,6 @@ else
 
     protected override async Task OnInitializedAsync()
     {
-        persistingSubscription = 
-            ApplicationState.RegisterOnPersisting(PersistForecasts);
-
         if (!ApplicationState.TryTakeFromJson<WeatherForecast[]>(
             "fetchdata", out var restored))
         {
@@ -1042,9 +1039,12 @@ else
         {
             forecasts = restored!;
         }
+
+        // Call at the end to avoid a potential race condition at app shutdown
+        persistingSubscription = ApplicationState.RegisterOnPersisting(PersistData);
     }
 
-    private Task PersistForecasts()
+    private Task PersistData()
     {
         ApplicationState.PersistAsJson("fetchdata", forecasts);
 

aspnetcore/blazor/components/integration.md

@@ -402,7 +402,7 @@ In `Pages/_Host.cshtml` of Blazor apps that are `ServerPrerendered` in a Blazor
 </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.
+Decide what state to persist using the <xref:Microsoft.AspNetCore.Components.PersistentComponentState> service. <xref:Microsoft.AspNetCore.Components.PersistentComponentState.RegisterOnPersisting%2A?displayProperty=nameWithType> registers a callback to persist the component state before the app is paused. The state is retrieved when the application resumes. Make the call at the end of initialization code in order to avoid a potential race condition during app shutdown.
 
 In the following example:
 
@@ -421,9 +421,6 @@ In the following example:
 
     protected override async Task OnInitializedAsync()
     {
-        persistingSubscription = 
-            ApplicationState.RegisterOnPersisting(PersistData);
-
         if (!ApplicationState.TryTakeFromJson<{TYPE}>(
             "{TOKEN}", out var restored))
         {
@@ -433,6 +430,9 @@ In the following example:
         {
             data = restored!;
         }
+
+        // Call at the end to avoid a potential race condition at app shutdown
+        persistingSubscription = ApplicationState.RegisterOnPersisting(PersistData);
     }
 
     private Task PersistData()
@@ -501,22 +501,23 @@ else
 
     protected override async Task OnInitializedAsync()
     {
-        persistingSubscription = 
-            ApplicationState.RegisterOnPersisting(PersistForecasts);
-
         if (!ApplicationState.TryTakeFromJson<WeatherForecast[]>(
             "fetchdata", out var restored))
         {
             forecasts = 
-                await WeatherForecastService.GetForecastAsync(DateOnly.FromDateTime(DateTime.Now));
+                await WeatherForecastService.GetForecastAsync(
+                    DateOnly.FromDateTime(DateTime.Now));
         }
         else
         {
             forecasts = restored!;
         }
+
+        // Call at the end to avoid a potential race condition at app shutdown
+        persistingSubscription = ApplicationState.RegisterOnPersisting(PersistData);
     }
 
-    private Task PersistForecasts()
+    private Task PersistData()
     {
         ApplicationState.PersistAsJson("fetchdata", forecasts);
 
@@ -966,7 +967,7 @@ To solve these problems, Blazor supports persisting state in a prerendered page
 </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.
+Decide what state to persist using the <xref:Microsoft.AspNetCore.Components.PersistentComponentState> service. <xref:Microsoft.AspNetCore.Components.PersistentComponentState.RegisterOnPersisting%2A?displayProperty=nameWithType> registers a callback to persist the component state before the app is paused. The state is retrieved when the application resumes. Make the call at the end of initialization code in order to avoid a potential race condition during app shutdown.
 
 The following example is an updated version of the `FetchData` component 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.
 
@@ -1020,9 +1021,6 @@ else
 
     protected override async Task OnInitializedAsync()
     {
-        persistingSubscription = 
-            ApplicationState.RegisterOnPersisting(PersistForecasts);
-
         if (!ApplicationState.TryTakeFromJson<WeatherForecast[]>(
             "fetchdata", out var restored))
         {
@@ -1033,9 +1031,12 @@ else
         {
             forecasts = restored!;
         }
+
+        // Call at the end to avoid a potential race condition at app shutdown
+        persistingSubscription = ApplicationState.RegisterOnPersisting(PersistData);
     }
 
-    private Task PersistForecasts()
+    private Task PersistData()
     {
         ApplicationState.PersistAsJson("fetchdata", forecasts);
 

aspnetcore/blazor/components/lifecycle.md

@@ -639,9 +639,6 @@ else
 
     protected override async Task OnInitializedAsync()
     {
-        persistingSubscription =
-            ApplicationState.RegisterOnPersisting(PersistData);
-
         if (!ApplicationState.TryTakeFromJson<string>("data", out var restored))
         {
             data = await LoadDataAsync();
@@ -650,6 +647,9 @@ else
         {
             data = restored!;
         }
+
+        // Call at the end to avoid a potential race condition at app shutdown
+        persistingSubscription = ApplicationState.RegisterOnPersisting(PersistData);
     }
 
     private Task PersistData()

aspnetcore/blazor/components/prerender.md

@@ -45,7 +45,7 @@ The first logged count occurs during prerendering. The count is set again after
 
 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. <xref:Microsoft.AspNetCore.Components.PersistentComponentState.RegisterOnPersisting%2A?displayProperty=nameWithType> registers a callback to persist the component state before the app is paused. The state is retrieved when the app resumes.
+To preserve prerendered state, decide what state to persist using the <xref:Microsoft.AspNetCore.Components.PersistentComponentState> service. <xref:Microsoft.AspNetCore.Components.PersistentComponentState.RegisterOnPersisting%2A?displayProperty=nameWithType> registers a callback to persist the component state before the app is paused. The state is retrieved when the app resumes. Make the call at the end of initialization code in order to avoid a potential race condition during app shutdown.
 
 The following example demonstrates the general pattern:
 
@@ -64,9 +64,6 @@ The following example demonstrates the general pattern:
 
     protected override async Task OnInitializedAsync()
     {
-        persistingSubscription = 
-            ApplicationState.RegisterOnPersisting(PersistData);
-
         if (!ApplicationState.TryTakeFromJson<{TYPE}>(
             "{TOKEN}", out var restored))
         {
@@ -76,6 +73,9 @@ The following example demonstrates the general pattern:
         {
             data = restored!;
         }
+
+        // Call at the end to avoid a potential race condition at app shutdown
+        persistingSubscription = ApplicationState.RegisterOnPersisting(PersistData);
     }
 
     private Task PersistData()

aspnetcore/blazor/security/index.md

@@ -627,7 +627,7 @@ internal sealed class ClientWeatherForecaster(HttpClient httpClient)
 The client project maintains a `Weather` component that:
 
 * Enforces authorization with an [`[Authorize]` attribute](xref:Microsoft.AspNetCore.Authorization.AuthorizeAttribute).
-* Uses the [Persistent Component State service](xref:blazor/components/prerender#persist-prerendered-state) (<xref:Microsoft.AspNetCore.Components.PersistentComponentState>) to persist weather forecast data when the component transitions from static to interactive SSR on the server.
+* Uses the [Persistent Component State service](xref:blazor/components/prerender#persist-prerendered-state) (<xref:Microsoft.AspNetCore.Components.PersistentComponentState>) to persist weather forecast data when the component transitions from static to interactive SSR on the server. For more information, see <xref:blazor/components/prerender#persist-prerendered-state>.
 
 ```razor
 @page "/weather"
@@ -679,8 +679,6 @@ else
 
     protected override async Task OnInitializedAsync()
     {
-        persistingSubscription = ApplicationState.RegisterOnPersisting(PersistData);
-
         if (!ApplicationState.TryTakeFromJson<IEnumerable<WeatherForecast>>(
             nameof(forecasts), out var restoredData))
         {
@@ -690,6 +688,9 @@ else
         {
             forecasts = restoredData!;
         }
+
+        // Call at the end to avoid a potential race condition at app shutdown
+        persistingSubscription = ApplicationState.RegisterOnPersisting(PersistData);
     }
 
     private Task PersistData()

aspnetcore/host-and-deploy/iis/advanced.md

@@ -18,8 +18,7 @@ This article covers advanced configuration options and scenarios for the ASP.NET
 
 *Only applies when using the in-process hosting model.*
 
-:::moniker range="> aspnetcore-9.0"
-Configure the managed stack size using the `stackSize` setting in bytes in hexadecimal in the `web.config` file. The default size is 1,048,576 bytes (1 MB) expressed in hexadecimal. The following example changes the stack size to 2 MB (2,097,152 bytes) in hexadecimal 0x200000:
+Configure the managed stack size using the `stackSize` setting in hexadecimal bytes in the `web.config` file. The default size is 0x100000 bytes (1 MB). The following example changes the stack size to 2 MB (2,097,152 bytes) in hexadecimal 0x200000:
 
 ```xml
 <aspNetCore processPath="dotnet"
@@ -33,26 +32,6 @@ Configure the managed stack size using the `stackSize` setting in bytes in hexad
 </aspNetCore>
 ```
 
-:::moniker-end
-
-:::moniker range="<= aspnetcore-9.0"
-
-Configure the managed stack size using the `stackSize` setting in bytes in the `web.config` file. The default size is 17,825,792 bytes (17 MB). The following example changes the stack size to 100,000 hex, (1 MB):
-
-```xml
-<aspNetCore processPath="dotnet"
-    arguments=".\MyApp.dll"
-    stdoutLogEnabled="false"
-    stdoutLogFile="\\?\%home%\LogFiles\stdout"
-    hostingModel="inprocess">
-  <handlerSettings>
-    <handlerSetting name="stackSize" value="100000" />
-  </handlerSettings>
-</aspNetCore>
-```
-
-:::moniker-end
-
 ## Disallow rotation on config
 
 The `disallowRotationOnConfigChange` setting is intended for blue/green scenarios where a change to global config should not cause all sites to recycle. When this flag is true, only changes relevant to the site itself will cause it to recycle. For example, a site recycles if its *web.config* changes or something changes that is relevant to the site's path from IIS's perspective. But a general change to *applicationHost.config* would not cause an app to recycle. The following example sets this setting to true:

aspnetcore/signalr/supported-platforms.md

@@ -5,7 +5,7 @@ description: Learn about the supported platforms for ASP.NET Core SignalR.
 monikerRange: '>= aspnetcore-3.1'
 ms.author: wpickett
 ms.custom: mvc, devx-track-js
-ms.date: 01/09/2025
+ms.date: 04/01/2025
 uid: signalr/supported-platforms
 ---
 # ASP.NET Core SignalR supported platforms
@@ -41,13 +41,12 @@ The [Java client](xref:signalr/java-client) supports Java 8 and later versions.
 
 ## Swift client
 
-The [Swift client](https://github.com/dotnet/signalr-client-swift) supports Swift >= 5.10
+The [Swift client](xref:signalr/swift-client) supports Swift >= 5.10
 
 ## Unsupported clients
 
-The following clients are available but are experimental or unofficial. The following clients aren't currently supported and may never be supported:
+The following client is available for experimentation only, isn't currently supported, and may never be supported:
 
 * [C++ client](https://github.com/aspnet/SignalR-Client-Cpp)
-* [3rd party Swift client](https://github.com/moozzyk/SignalR-Client-Swift)
 
 [!INCLUDE[](~/includes/SignalR/es6.md)]