Merge pull request #26189 from dotnet-maestro-bot/merge/release/5.0-rc2-to-master

[automated] Merge branch 'release/5.0-rc2' => 'master'

Author: dougbu

eng/Versions.props

@@ -20,8 +20,6 @@
     <IncludePreReleaseLabelInPackageVersion>true</IncludePreReleaseLabelInPackageVersion>
     <IncludePreReleaseLabelInPackageVersion Condition=" '$(DotNetFinalVersionKind)' == 'release' ">false</IncludePreReleaseLabelInPackageVersion>
     <AspNetCoreMajorMinorVersion>$(AspNetCoreMajorVersion).$(AspNetCoreMinorVersion)</AspNetCoreMajorMinorVersion>
-    <!-- Additional assembly attributes are already configured to include the source revision ID. -->
-    <IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
     <!--
       Until package baselines are updated (see dotnet/aspnetcore#12702), ignore them and PatchConfig.props. This also
       gives us time to build the entire repo and settle the infrastructure. Do _not_ do this when stabilizing versions.

src/Components/Web.JS/dist/Release/blazor.server.js

@@ -309,11 +309,6 @@ function createEmscriptenModuleInstance(resourceLoader: WebAssemblyResourceLoade
       const satelliteResources = resourceLoader.bootConfig.resources.satelliteResources;
       const applicationCulture = resourceLoader.startOptions.applicationCulture || (navigator.languages && navigator.languages[0]);
 
-      if (resourceLoader.bootConfig.icuDataMode == ICUDataMode.Sharded && culturesToLoad && culturesToLoad[0] !== applicationCulture) {
-        // We load an initial icu file based on the browser's locale. However if the application's culture requires a different set, flag this as an error.
-        throw new Error('To change culture dynamically during startup, set <BlazorWebAssemblyLoadAllGlobalizationData>true</BlazorWebAssemblyLoadAllGlobalizationData> in the application\'s project file.');
-      }
-
       if (satelliteResources) {
         const resourcePromises = Promise.all(culturesToLoad
           .filter(culture => satelliteResources.hasOwnProperty(culture))
@@ -354,19 +349,42 @@ function createEmscriptenModuleInstance(resourceLoader: WebAssemblyResourceLoade
         throw new Error(`${notMarked.join()} must be marked with 'BlazorWebAssemblyLazyLoad' item group in your project file to allow lazy-loading.`);
       }
 
+      let pdbPromises: Promise<(ArrayBuffer | null)[]> | undefined;
+      if (hasDebuggingEnabled()) {
+        const pdbs = resourceLoader.bootConfig.resources.pdb;
+        const pdbsToLoad = assembliesMarkedAsLazy.map(a => changeExtension(a, '.pdb'))
+        if (pdbs) {
+          pdbPromises = Promise.all(pdbsToLoad
+            .map(pdb => lazyAssemblies.hasOwnProperty(pdb) ? resourceLoader.loadResource(pdb, `_framework/${pdb}`, lazyAssemblies[pdb], 'pdb') : null)
+            .map(async resource => resource ? (await resource.response).arrayBuffer() : null));
+        }
+      }
+
       const resourcePromises = Promise.all(assembliesMarkedAsLazy
         .map(assembly => resourceLoader.loadResource(assembly, `_framework/${assembly}`, lazyAssemblies[assembly], 'assembly'))
         .map(async resource => (await resource.response).arrayBuffer()));
 
       return BINDING.js_to_mono_obj(
-        resourcePromises.then(resourcesToLoad => {
+        Promise.all([resourcePromises, pdbPromises]).then(values => {
+          const resourcesToLoad = values[0];
+          const pdbsToLoad = values[1];
           if (resourcesToLoad.length) {
             window['Blazor']._internal.readLazyAssemblies = () => {
-              const array = BINDING.mono_obj_array_new(resourcesToLoad.length);
-              for (var i = 0; i < resourcesToLoad.length; i++) {
-                BINDING.mono_obj_array_set(array, i, BINDING.js_typed_array_to_array(new Uint8Array(resourcesToLoad[i])));
+              const assemblyBytes = BINDING.mono_obj_array_new(resourcesToLoad.length);
+              for (let i = 0; i < resourcesToLoad.length; i++) {
+                const assembly = resourcesToLoad[i] as ArrayBuffer;
+                BINDING.mono_obj_array_set(assemblyBytes, i, BINDING.js_typed_array_to_array(new Uint8Array(assembly)));
+              }
+              return assemblyBytes;
+            };
+
+            window['Blazor']._internal.readLazyPdbs = () => {
+              const pdbBytes = BINDING.mono_obj_array_new(resourcesToLoad.length);
+              for (let i = 0; i < resourcesToLoad.length; i++) {
+                const pdb = pdbsToLoad && pdbsToLoad[i] ? new Uint8Array(pdbsToLoad[i] as ArrayBufferLike) : new Uint8Array();
+                BINDING.mono_obj_array_set(pdbBytes, i, BINDING.js_typed_array_to_array(pdb));
               }
-              return array;
+              return pdbBytes;
             };
           }
 
@@ -381,6 +399,14 @@ function createEmscriptenModuleInstance(resourceLoader: WebAssemblyResourceLoade
     }
     resourceLoader.purgeUnusedCacheEntriesAsync(); // Don't await - it's fine to run in background
 
+    if (resourceLoader.bootConfig.icuDataMode === ICUDataMode.Sharded) {
+      MONO.mono_wasm_setenv('__BLAZOR_SHARDED_ICU',  '1');
+
+      if (resourceLoader.startOptions.applicationCulture) {
+        // If a culture is specified via start options use that to initialize the Emscripten \  .NET culture.
+        MONO.mono_wasm_setenv('LANG',  `${resourceLoader.startOptions.applicationCulture}.UTF-8`);
+      }
+    }
     MONO.mono_wasm_setenv("MONO_URI_DOTNETRELATIVEORABSOLUTE", "true");
     let timeZone = "UTC";
     try {
@@ -498,7 +524,7 @@ async function loadTimezone(timeZoneResource: LoadingResource): Promise<void> {
 
 function getICUResourceName(bootConfig: BootJsonData, culture: string | undefined): string {
   const combinedICUResourceName = 'icudt.dat';
-  if (!culture || bootConfig.icuDataMode == ICUDataMode.All) {
+  if (!culture || bootConfig.icuDataMode === ICUDataMode.All) {
     return combinedICUResourceName;
   }
 

src/Components/Web.JS/dist/Release/blazor.webassembly.js

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -97,6 +98,20 @@ public sealed class Virtualize<TItem> : ComponentBase, IVirtualizeJsCallbacks, I
         [Parameter]
         public int OverscanCount { get; set; } = 3;
 
+        /// <summary>
+        /// Instructs the component to re-request data from its <see cref="ItemsProvider"/>.
+        /// This is useful if external data may have changed. There is no need to call this
+        /// when using <see cref="Items"/>.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the completion of the operation.</returns>
+        public async Task RefreshDataAsync()
+        {
+            // We don't auto-render after this operation because in the typical use case, the
+            // host component calls this from one of its lifecycle methods, and will naturally
+            // re-render afterwards anyway. It's not desirable to re-render twice.
+            await RefreshDataCoreAsync(renderOnSuccess: false);
+        }
+
         /// <inheritdoc />
         protected override void OnParametersSet()
         {
@@ -125,6 +140,14 @@ protected override void OnParametersSet()
             else if (Items != null)
             {
                 _itemsProvider = DefaultItemsProvider;
+
+                // When we have a fixed set of in-memory data, it doesn't cost anything to
+                // re-query it on each cycle, so do that. This means the developer can add/remove
+                // items in the collection and see the UI update without having to call RefreshDataAsync.
+                var refreshTask = RefreshDataCoreAsync(renderOnSuccess: false);
+
+                // We know it's synchronous and has its own error handling
+                Debug.Assert(refreshTask.IsCompletedSuccessfully);
             }
             else
             {
@@ -270,7 +293,7 @@ private void UpdateItemDistribution(int itemsBefore, int visibleItemCapacity)
             {
                 _itemsBefore = itemsBefore;
                 _visibleItemCapacity = visibleItemCapacity;
-                var refreshTask = RefreshDataAsync();
+                var refreshTask = RefreshDataCoreAsync(renderOnSuccess: true);
 
                 if (!refreshTask.IsCompleted)
                 {
@@ -279,12 +302,25 @@ private void UpdateItemDistribution(int itemsBefore, int visibleItemCapacity)
             }
         }
 
-        private async Task RefreshDataAsync()
+        private async ValueTask RefreshDataCoreAsync(bool renderOnSuccess)
         {
             _refreshCts?.Cancel();
-            _refreshCts = new CancellationTokenSource();
+            CancellationToken cancellationToken;
+
+            if (_itemsProvider == DefaultItemsProvider)
+            {
+                // If we're using the DefaultItemsProvider (because the developer supplied a fixed
+                // Items collection) we know it will complete synchronously, and there's no point
+                // instantiating a new CancellationTokenSource
+                _refreshCts = null;
+                cancellationToken = CancellationToken.None;
+            }
+            else
+            {
+                _refreshCts = new CancellationTokenSource();
+                cancellationToken = _refreshCts.Token;
+            }
 
-            var cancellationToken = _refreshCts.Token;
             var request = new ItemsProviderRequest(_itemsBefore, _visibleItemCapacity, cancellationToken);
 
             try
@@ -298,7 +334,10 @@ private async Task RefreshDataAsync()
                     _loadedItems = result.Items;
                     _loadedItemsStartIndex = request.StartIndex;
 
-                    StateHasChanged();
+                    if (renderOnSuccess)
+                    {
+                        StateHasChanged();
+                    }
                 }
             }
             catch (Exception e)

src/Components/Web.JS/src/Platform/Mono/MonoPlatform.ts

@@ -123,7 +123,12 @@ public void WriteBootJson(Stream output, string entryAssemblyName)
                     else if (string.Equals(extension, ".pdb", StringComparison.OrdinalIgnoreCase))
                     {
                         resourceData.pdb ??= new ResourceHashesByNameDictionary();
-                        resourceList = resourceData.pdb;
+                        if (IsLazyLoadedAssembly($"{fileName}.dll"))
+                        {
+                            resourceList = resourceData.lazyAssembly;
+                        } else {
+                            resourceList = resourceData.pdb;
+                        }
                     }
                     else if (string.Equals(extension, ".dll", StringComparison.OrdinalIgnoreCase))
                     {

src/Components/Web/src/Virtualization/Virtualize.cs

@@ -51,7 +51,7 @@ private static async Task<string> LaunchAndGetUrl(IServiceProvider serviceProvid
             var processStartInfo = new ProcessStartInfo
             {
                 FileName = muxerPath,
-                Arguments = $"exec \"{executablePath}\" --owner-pid {ownerPid} --DevToolsUrl {devToolsHost}",
+                Arguments = $"exec \"{executablePath}\" --OwnerPid {ownerPid} --DevToolsUrl {devToolsHost}",
                 UseShellExecute = false,
                 RedirectStandardOutput = true,
             };

src/Components/WebAssembly/Sdk/src/GenerateBlazorWebAssemblyBootJson.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using System.Globalization;
 using System.Linq;
 using System.Reflection;
 using System.Threading.Tasks;
@@ -17,6 +18,8 @@ internal static class EntrypointInvoker
         // do change this it will be non-breaking.
         public static async void InvokeEntrypoint(string assemblyName, string[] args)
         {
+             WebAssemblyCultureProvider.Initialize();
+
             try
             {
                 var assembly = Assembly.Load(assemblyName);

src/Components/WebAssembly/Server/src/DebugProxyLauncher.cs

@@ -1,27 +1,62 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
-using System.Reflection;
 using System.Runtime.Loader;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Components.WebAssembly.Services;
 
 namespace Microsoft.AspNetCore.Components.WebAssembly.Hosting
 {
-    internal class SatelliteResourcesLoader
+    internal class WebAssemblyCultureProvider
     {
         internal const string GetSatelliteAssemblies = "window.Blazor._internal.getSatelliteAssemblies";
         internal const string ReadSatelliteAssemblies = "window.Blazor._internal.readSatelliteAssemblies";
 
         private readonly WebAssemblyJSRuntimeInvoker _invoker;
 
         // For unit testing.
-        internal SatelliteResourcesLoader(WebAssemblyJSRuntimeInvoker invoker)
+        internal WebAssemblyCultureProvider(WebAssemblyJSRuntimeInvoker invoker, CultureInfo initialCulture, CultureInfo initialUICulture)
         {
             _invoker = invoker;
+            InitialCulture = initialCulture;
+            InitialUICulture = initialUICulture;
+        }
+
+        public static WebAssemblyCultureProvider Instance { get; private set; }
+
+        public CultureInfo InitialCulture { get; }
+
+        public CultureInfo InitialUICulture { get; }
+
+        internal static void Initialize()
+        {
+            Instance = new WebAssemblyCultureProvider(
+                WebAssemblyJSRuntimeInvoker.Instance,
+                initialCulture: CultureInfo.CurrentCulture,
+                initialUICulture: CultureInfo.CurrentUICulture);
+        }
+
+        public void ThrowIfCultureChangeIsUnsupported()
+        {
+            // With ICU sharding enabled, bootstrapping WebAssembly will download a ICU shard based on the browser language.
+            // If the application author was to change the culture as part of their Program.MainAsync, we might have
+            // incomplete icu data for their culture. We would like to flag this as an error and notify the author to
+            // use the combined icu data file instead.
+            //
+            // The Initialize method is invoked as one of the first steps bootstrapping the app prior to any user code running.
+            // It allows us to capture the initial .NET culture that is configured based on the browser language.
+            // The current method is invoked as part of WebAssemblyHost.RunAsync i.e. after user code in Program.MainAsync has run
+            // thus allows us to detect if the culture was changed by user code.
+            if (Environment.GetEnvironmentVariable("__BLAZOR_SHARDED_ICU") == "1" &&
+                ((CultureInfo.CurrentCulture != InitialCulture) || (CultureInfo.CurrentUICulture != InitialUICulture)))
+            {
+                throw new InvalidOperationException("Blazor detected a change in the application's culture that is not supported with the current project configuration. " +
+                    "To change culture dynamically during startup, set <BlazorWebAssemblyLoadAllGlobalizationData>true</BlazorWebAssemblyLoadAllGlobalizationData> in the application's project file.");
+            }
         }
 
         public virtual async ValueTask LoadCurrentCultureResourcesAsync()

src/Components/WebAssembly/WebAssembly/src/Hosting/EntrypointInvoker.cs

@@ -59,7 +59,7 @@ internal WebAssemblyHost(IServiceProvider services, IServiceScope scope, IConfig
         /// </summary>
         public IServiceProvider Services => _scope.ServiceProvider;
 
-        internal SatelliteResourcesLoader SatelliteResourcesLoader { get; set; } = new SatelliteResourcesLoader(WebAssemblyJSRuntimeInvoker.Instance);
+        internal WebAssemblyCultureProvider CultureProvider { get; set; } = WebAssemblyCultureProvider.Instance;
 
         /// <summary>
         /// Disposes the host asynchronously.
@@ -121,11 +121,13 @@ internal async Task RunAsyncCore(CancellationToken cancellationToken)
 
             _started = true;
 
+            CultureProvider.ThrowIfCultureChangeIsUnsupported();
+
             // EntryPointInvoker loads satellite assemblies for the application default culture.
             // 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 SatelliteResourcesLoader.LoadCurrentCultureResourcesAsync();
+            await CultureProvider.LoadCurrentCultureResourcesAsync();
 
             var tcs = new TaskCompletionSource<object>();