diff --git a/.github/workflows/quest-bulk.yml b/.github/workflows/quest-bulk.yml index 75c7724668b0..60db1feaeaff 100644 --- a/.github/workflows/quest-bulk.yml +++ b/.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 }} diff --git a/.github/workflows/quest.yml b/.github/workflows/quest.yml index f0b5f01feaa3..ce5d13549beb 100644 --- a/.github/workflows/quest.yml +++ b/.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 }} diff --git a/aspnetcore/blazor/components/integration-hosted-webassembly.md b/aspnetcore/blazor/components/integration-hosted-webassembly.md index 69b8f4b10b95..6f80a7befae1 100644 --- a/aspnetcore/blazor/components/integration-hosted-webassembly.md +++ b/aspnetcore/blazor/components/integration-hosted-webassembly.md @@ -415,7 +415,7 @@ In `Pages/_Host.cshtml` of Blazor apps that are WebAssembly prerendered (`WebAss ``` -Decide what state to persist using the 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 service. 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( "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 ``` -Decide what state to persist using the 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 service. 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( "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); diff --git a/aspnetcore/blazor/components/integration.md b/aspnetcore/blazor/components/integration.md index 62785ea8d7be..b51fe0bb4adc 100644 --- a/aspnetcore/blazor/components/integration.md +++ b/aspnetcore/blazor/components/integration.md @@ -402,7 +402,7 @@ In `Pages/_Host.cshtml` of Blazor apps that are `ServerPrerendered` in a Blazor ``` -Decide what state to persist using the 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 service. 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( "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 ``` -Decide what state to persist using the 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 service. 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( "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); diff --git a/aspnetcore/blazor/components/lifecycle.md b/aspnetcore/blazor/components/lifecycle.md index a515f41f1fa6..ef38c697d71f 100644 --- a/aspnetcore/blazor/components/lifecycle.md +++ b/aspnetcore/blazor/components/lifecycle.md @@ -639,9 +639,6 @@ else protected override async Task OnInitializedAsync() { - persistingSubscription = - ApplicationState.RegisterOnPersisting(PersistData); - if (!ApplicationState.TryTakeFromJson("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() diff --git a/aspnetcore/blazor/components/prerender.md b/aspnetcore/blazor/components/prerender.md index baded2b265d4..1fdbe8b965c5 100644 --- a/aspnetcore/blazor/components/prerender.md +++ b/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 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 service. 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 service. 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() diff --git a/aspnetcore/blazor/security/index.md b/aspnetcore/blazor/security/index.md index 601bbff700bc..9764666239a7 100644 --- a/aspnetcore/blazor/security/index.md +++ b/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) () 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) () to persist weather forecast data when the component transitions from static to interactive SSR on the server. For more information, see . ```razor @page "/weather" @@ -679,8 +679,6 @@ else protected override async Task OnInitializedAsync() { - persistingSubscription = ApplicationState.RegisterOnPersisting(PersistData); - if (!ApplicationState.TryTakeFromJson>( 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() diff --git a/aspnetcore/host-and-deploy/iis/advanced.md b/aspnetcore/host-and-deploy/iis/advanced.md index cf95b253f6c9..e2b23ab96e7f 100644 --- a/aspnetcore/host-and-deploy/iis/advanced.md +++ b/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 ``` -:::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 - - - - - -``` - -:::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: diff --git a/aspnetcore/signalr/supported-platforms.md b/aspnetcore/signalr/supported-platforms.md index c168aba8102a..935354c0b059 100644 --- a/aspnetcore/signalr/supported-platforms.md +++ b/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)]