Added Culture persistence between Client and Server

src/Components/Endpoints/src/Microsoft.AspNetCore.Components.Endpoints.csproj

@@ -31,6 +31,7 @@
     <Compile Include="$(RepoRoot)src\Shared\ClosedGenericMatcher\ClosedGenericMatcher.cs" LinkBase="FormMapping" />
     <Compile Include="$(ComponentsSharedSourceRoot)src\CacheHeaderSettings.cs" Link="Shared\CacheHeaderSettings.cs" />
     <Compile Include="$(ComponentsSharedSourceRoot)src\ResourceCollectionProvider.cs" Link="Shared\ResourceCollectionProvider.cs" />
+    <Compile Include="$(ComponentsSharedSourceRoot)src\CultureStateProvider.cs" Link="Shared\CultureStateProvider.cs" />
     <Compile Include="$(ComponentsSharedSourceRoot)src\DefaultAntiforgeryStateProvider.cs" LinkBase="Forms" />
     <Compile Include="$(SharedSourceRoot)LinkerFlags.cs" LinkBase="Shared" />
     <Compile Include="$(SharedSourceRoot)Components\ComponentsActivityLinkStore.cs" LinkBase="Shared" />

src/Components/Shared/src/CultureStateProvider.cs

@@ -0,0 +1,52 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+using System.Globalization;
+
+namespace Microsoft.AspNetCore.Components.Forms;
+
+internal class CultureStateProvider
+{
+    protected string? _currentCultureName;
+    protected string? _currentUICultureName;
+
+    [PersistentState]
+    public string? CurrentCultureName
+    {
+        get => _currentCultureName;
+        set => _currentCultureName = value;
+    }
+
+    [PersistentState]
+    public string? CurrentUICultureName
+    {
+        get => _currentUICultureName;
+        set => _currentUICultureName = value;
+    }
+
+    /// <summary>
+    /// Captures the current thread culture for persistence.
+    /// Called from server-side during prerendering.
+    /// </summary>
+    public void CaptureCurrentCulture()
+    {
+        CurrentCultureName = CultureInfo.CurrentCulture.Name;
+        CurrentUICultureName = CultureInfo.CurrentUICulture.Name;
+    }
+
+    /// <summary>
+    /// Applies the stored culture to the current thread.
+    /// Called on WebAssembly side after hydration.
+    /// </summary>
+    public void ApplyStoredCulture()
+    {
+        if (!string.IsNullOrEmpty(CurrentCultureName))
+        {
+            CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo(CurrentCultureName);
+        }
+
+        if (!string.IsNullOrEmpty(CurrentUICultureName))
+        {
+            CultureInfo.CurrentUICulture = CultureInfo.GetCultureInfo(CurrentUICultureName);
+        }
+    }
+}

src/Components/WebAssembly/Server/src/Microsoft.AspNetCore.Components.WebAssembly.Server.csproj

@@ -27,7 +27,7 @@
   <ItemGroup>
     <Compile Include="$(ComponentsSharedSourceRoot)\src\CacheHeaderSettings.cs" Link="Shared\CacheHeaderSettings.cs" />
     <Compile Include="$(SharedSourceRoot)\CommandLineUtils\Utilities\DotNetMuxer.cs" Link="Shared\DotNetMuxer.cs" />
-
+    <Compile Include="$(ComponentsSharedSourceRoot)src\CultureStateProvider.cs" Link="Shared\CultureStateProvider.cs" />
     <Content Include="build\**" Pack="true" PackagePath="build\%(RecursiveDir)%(FileName)%(Extension)" />
   </ItemGroup>
 

src/Components/WebAssembly/Server/src/PublicAPI.Unshipped.txt

@@ -1 +1,2 @@
 #nullable enable
+static Microsoft.Extensions.DependencyInjection.WebAssemblyRazorComponentsBuilderExtensions.EnforceServerCultureOnClient(this Microsoft.Extensions.DependencyInjection.IRazorComponentsBuilder! builder) -> Microsoft.Extensions.DependencyInjection.IRazorComponentsBuilder!

src/Components/WebAssembly/Server/src/WebAssemblyRazorComponentsBuilderExtensions.cs

@@ -7,6 +7,9 @@
 using Microsoft.AspNetCore.Components.WebAssembly.Server;
 using Microsoft.AspNetCore.Components.WebAssembly.Services;
 using Microsoft.Extensions.DependencyInjection.Extensions;
+using Microsoft.AspNetCore.Components.Forms;
+using Microsoft.AspNetCore.Components.Web;
+using Microsoft.AspNetCore.Components.Infrastructure;
 
 namespace Microsoft.Extensions.DependencyInjection;
 
@@ -48,4 +51,25 @@ public static IRazorComponentsBuilder AddAuthenticationStateSerialization(this I
 
         return builder;
     }
+
+    /// <summary>
+    /// Adds services to enforce Server culture on the Client side.
+    /// </summary>
+    /// <param name="builder">The <see cref="IRazorComponentsBuilder"/>.</param>
+    /// <returns>An <see cref="IRazorComponentsBuilder"/> that can be used to further customize the configuration.</returns>
+    public static IRazorComponentsBuilder EnforceServerCultureOnClient(this IRazorComponentsBuilder builder)
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+
+        builder.Services.TryAddScoped(_ =>
+        {
+            var provider = new CultureStateProvider();
+            provider.CaptureCurrentCulture();
+            return provider;
+        });
+        RegisterPersistentComponentStateServiceCollectionExtensions.AddPersistentServiceRegistration<CultureStateProvider>(
+            builder.Services,
+            RenderMode.InteractiveWebAssembly);
+        return builder;
+    }
 }

src/Components/WebAssembly/WebAssembly/src/Hosting/WebAssemblyHost.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Diagnostics.CodeAnalysis;
+using Microsoft.AspNetCore.Components.Forms;
 using Microsoft.AspNetCore.Components.Infrastructure;
 using Microsoft.AspNetCore.Components.Web;
 using Microsoft.AspNetCore.Components.Web.Infrastructure;
@@ -121,14 +122,6 @@ internal async Task RunAsyncCore(CancellationToken cancellationToken, WebAssembl
 
         _started = true;
 
-        cultureProvider ??= WebAssemblyCultureProvider.Instance!;
-        cultureProvider.ThrowIfCultureChangeIsUnsupported();
-
-        // Application developers might have configured the culture based on some ambient state
-        // such as local storage, url etc as part of their Program.Main(Async).
-        // This is the earliest opportunity to fetch satellite assemblies for this selection.
-        await cultureProvider.LoadCurrentCultureResourcesAsync();
-
         var manager = Services.GetRequiredService<ComponentStatePersistenceManager>();
         var store = !string.IsNullOrEmpty(_persistedState) ?
             new PrerenderComponentApplicationStore(_persistedState) :
@@ -137,6 +130,19 @@ internal async Task RunAsyncCore(CancellationToken cancellationToken, WebAssembl
         manager.SetPlatformRenderMode(RenderMode.InteractiveWebAssembly);
         await manager.RestoreStateAsync(store);
 
+        cultureProvider ??= WebAssemblyCultureProvider.Instance!;
+        cultureProvider.ThrowIfCultureChangeIsUnsupported();
+
+        if (Services.GetService<CultureStateProvider>() is CultureStateProvider cultureStateProvider)
+        {
+            cultureStateProvider.ApplyStoredCulture();
+        }
+
+        // Application developers might have configured the culture based on some ambient state
+        // such as local storage, url etc as part of their Program.Main(Async).
+        // This is the earliest opportunity to fetch satellite assemblies for this selection.
+        await cultureProvider.LoadCurrentCultureResourcesAsync();
+
         var tcs = new TaskCompletionSource();
         using (cancellationToken.Register(() => tcs.TrySetResult()))
         {

src/Components/WebAssembly/WebAssembly/src/Hosting/WebAssemblyHostBuilder.cs

@@ -336,6 +336,8 @@ internal void InitializeDefaultServices()
         });
         Services.AddSingleton<AntiforgeryStateProvider, DefaultAntiforgeryStateProvider>();
         RegisterPersistentComponentStateServiceCollectionExtensions.AddPersistentServiceRegistration<AntiforgeryStateProvider>(Services, RenderMode.InteractiveWebAssembly);
+        Services.AddSingleton<CultureStateProvider>();
+        RegisterPersistentComponentStateServiceCollectionExtensions.AddPersistentServiceRegistration<CultureStateProvider>(Services, RenderMode.InteractiveWebAssembly);
         Services.AddSupplyValueFromQueryProvider();
     }
 }

src/Components/WebAssembly/WebAssembly/src/Microsoft.AspNetCore.Components.WebAssembly.csproj

@@ -44,6 +44,7 @@
     <Compile Include="$(SharedSourceRoot)LinkerFlags.cs" LinkBase="Shared" />
     <Compile Include="$(ComponentsSharedSourceRoot)src\DefaultAntiforgeryStateProvider.cs" LinkBase="Forms" />
     <Compile Include="$(ComponentsSharedSourceRoot)src\ResourceCollectionProvider.cs" Link="Shared\ResourceCollectionProvider.cs" />
+    <Compile Include="$(ComponentsSharedSourceRoot)src\CultureStateProvider.cs" Link="Shared\CultureStateProvider.cs" />
   </ItemGroup>
 
   <ItemGroup>

src/Components/test/E2ETest/ServerRenderingTests/InteractivityTest.cs

@@ -1202,6 +1202,41 @@ public void CanPersistPrerenderedState_WebAssemblyPrerenderedStateAvailableOnlyO
         Browser.Equal("not restored", () => Browser.FindElement(By.Id("wasm")).Text);
     }
 
+    [Fact]
+    public void CanPersistCultureFromServer()
+    {
+        _serverFixture.AdditionalArguments.Add("EnforceServerCultureOnClient=true");
+
+        Navigate($"{ServerPathBase}/Culture/SetCulture?culture=fr-FR&redirectUri={Uri.EscapeDataString($"{ServerPathBase}/persist-culture-state")}");
+        Browser.Exists(By.ClassName("return-from-culture-setter")).Click();
+
+        Browser.Equal("Prerender", () => Browser.FindElement(By.Id("prerender")).Text);
+        Browser.Equal("fr-FR", () => Browser.FindElement(By.Id("culture-set")).Text);
+        Browser.Equal("fr-FR", () => Browser.FindElement(By.Id("culture-ui-set")).Text);
+
+        Browser.Exists(By.Id("start-blazor")).Click();
+
+        Browser.Equal("Interactive", () => Browser.FindElement(By.Id("interactive")).Text);
+        Browser.Equal("fr-FR", () => Browser.FindElement(By.Id("culture-set")).Text);
+    }
+
+    [Fact]
+    public void DoesNotPersistCultureFromServerAsDefault()
+    {
+        Navigate($"{ServerPathBase}/Culture/SetCulture?culture=fr-FR&redirectUri={Uri.EscapeDataString($"{ServerPathBase}/persist-culture-state")}");
+        Browser.Exists(By.ClassName("return-from-culture-setter")).Click();
+
+        Browser.Equal("Prerender", () => Browser.FindElement(By.Id("prerender")).Text);
+        Browser.Equal("fr-FR", () => Browser.FindElement(By.Id("culture-set")).Text);
+        Browser.Equal("fr-FR", () => Browser.FindElement(By.Id("culture-ui-set")).Text);
+
+        Browser.Exists(By.Id("start-blazor")).Click();
+
+        Browser.Equal("Interactive", () => Browser.FindElement(By.Id("interactive")).Text);
+        Browser.NotEqual("fr-FR", () => Browser.FindElement(By.Id("culture-set")).Text);
+        Browser.NotEqual("fr-FR", () => Browser.FindElement(By.Id("culture-ui-set")).Text);
+    }
+
     [Fact]
     public void NavigationManagerCanRefreshSSRPageWhenServerInteractivityEnabled()
     {

src/Components/test/testassets/Components.TestServer/RazorComponentEndpointsStartup.cs

@@ -12,6 +12,7 @@
 using Microsoft.AspNetCore.Components.Server.Circuits;
 using Microsoft.AspNetCore.Components.Web;
 using Microsoft.AspNetCore.Components.WebAssembly.Server;
+using Microsoft.AspNetCore.Localization;
 using Microsoft.AspNetCore.Mvc;
 using TestContentPackage;
 using TestContentPackage.Services;
@@ -30,9 +31,10 @@ public RazorComponentEndpointsStartup(IConfiguration configuration)
     // This method gets called by the runtime. Use this method to add services to the container.
     public void ConfigureServices(IServiceCollection services)
     {
+        services.AddControllers();
         services.AddValidation();
 
-        services.AddRazorComponents(options =>
+        var razorComponentsBuilder = services.AddRazorComponents(options =>
         {
             options.MaxFormMappingErrorCount = 10;
             options.MaxFormMappingRecursionDepth = 5;
@@ -57,6 +59,11 @@ public void ConfigureServices(IServiceCollection services)
                 options.SerializeAllClaims = serializeAllClaims;
             });
 
+        if (Configuration.GetValue<bool>("EnforceServerCultureOnClient"))
+        {
+            razorComponentsBuilder.EnforceServerCultureOnClient();
+        }
+
         if (Configuration.GetValue<bool>("UseHybridCache"))
         {
             services.AddHybridCache();
@@ -93,6 +100,15 @@ public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
 
         app.Map("/subdir", app =>
         {
+            app.UseRequestLocalization(options =>
+            {
+                options.AddSupportedCultures("en-US", "fr-FR");
+                options.AddSupportedUICultures("en-US", "fr-FR");
+                options.RequestCultureProviders.Clear();
+                options.RequestCultureProviders.Add(new CookieRequestCultureProvider());
+                options.SetDefaultCulture("en-US");
+            });
+
             app.Map("/reexecution", reexecutionApp =>
             {
                 app.Map("/trigger-404", app =>
@@ -142,6 +158,8 @@ private void ConfigureEndpoints(IApplicationBuilder app, IWebHostEnvironment env
     {
         _ = app.UseEndpoints(endpoints =>
         {
+            endpoints.MapControllers();
+
             var contentRootStaticAssetsPath = Path.Combine(env.ContentRootPath, "Components.TestServer.staticwebassets.endpoints.json");
             if (File.Exists(contentRootStaticAssetsPath))
             {

src/Components/test/testassets/Components.WasmMinimal/Pages/CulturePersistence.razor

@@ -0,0 +1,41 @@
+@page "/persist-culture-state"
+@using System.Globalization
+@using Microsoft.AspNetCore.Components.Web
+@rendermode RenderMode.InteractiveWebAssembly
+
+<script>
+    function start() {
+        Blazor.start({
+            logLevel: 1 // LogLevel.Debug
+        });
+    }
+</script>
+
+<script src="_framework/blazor.webassembly.js" autostart="false"></script>
+
+<h3>CulturePersistence</h3>
+
+<p id="culture-set">@CultureInfo.CurrentCulture</p>
+<p id="culture-ui-set">@CultureInfo.CurrentUICulture</p>
+
+@if(RendererInfo.IsInteractive)
+{
+    <p id="interactive">Interactive</p>
+}
+else
+{
+    <p id="prerender">Prerender</p>
+}
+
+<button id="start-blazor" onclick="start()">Start Blazor</button>
+
+@code {
+    protected override void OnAfterRender(bool firstRender)
+    {
+        if (firstRender)
+        {
+            StateHasChanged();
+        }
+        base.OnAfterRender(firstRender);
+    }
+}