Remove Entrypoint Invoker

src/Components/.gitignore

@@ -0,0 +1 @@
+**/Samples/**/.vscode/*

src/Components/Web.JS/src/Boot.WebAssembly.ts

@@ -119,7 +119,7 @@ async function boot(options?: Partial<WebAssemblyStartOptions>): Promise<void> {
   }
 
   // Start up the application
-  platform.callEntryPoint(resourceLoader.bootConfig.entryAssembly);
+  await platform.callEntryPoint(resourceLoader.bootConfig.entryAssembly);
 }
 
 function invokeJSFromDotNet(callInfo: Pointer, arg0: any, arg1: any, arg2: any): any {

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

@@ -54,16 +54,15 @@ export const monoPlatform: Platform = {
     });
   },
 
-  callEntryPoint: function callEntryPoint(assemblyName: string) {
-    // Instead of using Module.mono_call_assembly_entry_point, we have our own logic for invoking
-    // the entrypoint which adds support for async main.
-    // Currently we disregard the return value from the entrypoint, whether it's sync or async.
-    // In the future, we might want Blazor.start to return a Promise<Promise<value>>, where the
-    // outer promise reflects the startup process, and the inner one reflects the possibly-async
-    // .NET entrypoint method.
-    const invokeEntrypoint = bindStaticMethod('Microsoft.AspNetCore.Components.WebAssembly', 'Microsoft.AspNetCore.Components.WebAssembly.Hosting.EntrypointInvoker', 'InvokeEntrypoint');
-    // Note we're passing in null because passing arrays is problematic until https://github.com/mono/mono/issues/18245 is resolved.
-    invokeEntrypoint(assemblyName, null);
+  callEntryPoint: async function callEntryPoint(assemblyName: string) : Promise<any> {
+    const emptyArray = [ [ ] ];
+
+    try {
+      await BINDING.call_assembly_entry_point(assemblyName, emptyArray, "m")
+    } catch (error) {
+      console.error(error);
+      showErrorNotification();
+    }
   },
 
   toUint8Array: function toUint8Array(array: System_Array<any>): Uint8Array {

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

@@ -21,6 +21,7 @@ declare interface BINDING {
   mono_array_to_js_array<TInput, TOutput>(array: System_Array<TInput>) : Array<TOutput>;
   conv_string(dotnetString: System_String | null): string | null;
   bind_static_method(fqn: string, signature?: string): Function;
+  call_assembly_entry_point(assemblyName: string, args: any[], signature: any): Promise<any>;
   unbox_mono_obj(object: System_Object): any;
 }
 

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

@@ -3,7 +3,7 @@ import { WebAssemblyResourceLoader } from './WebAssemblyResourceLoader';
 export interface Platform {
   start(resourceLoader: WebAssemblyResourceLoader): Promise<void>;
 
-  callEntryPoint(assemblyName: string): void;
+  callEntryPoint(assemblyName: string): Promise<any>;
 
   toUint8Array(array: System_Array<any>): Uint8Array;
 

src/Components/WebAssembly/WebAssembly/src/Hosting/WebAssemblyCultureProvider.cs

@@ -50,12 +50,13 @@ public void ThrowIfCultureChangeIsUnsupported()
             // 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.
+            // The Initialize method is invoked as one of the first steps bootstrapping the app within WebAssemblyHostBuilder.CreateDefault.
             // 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)))
+                ((!CultureInfo.CurrentCulture.Name.Equals(InitialCulture.Name, StringComparison.Ordinal) ||
+                  !CultureInfo.CurrentUICulture.Name.Equals(InitialUICulture.Name, StringComparison.Ordinal))))
             {
                 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.");

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

@@ -48,7 +48,6 @@ internal WebAssemblyHost(
             string? persistedState)
         {
             // To ensure JS-invoked methods don't get linked out, have a reference to their enclosing types
-            GC.KeepAlive(typeof(EntrypointInvoker));
             GC.KeepAlive(typeof(JSInteropMethods));
 
             _services = services;
@@ -68,8 +67,6 @@ internal WebAssemblyHost(
         /// </summary>
         public IServiceProvider Services => _scope.ServiceProvider;
 
-        internal WebAssemblyCultureProvider CultureProvider { get; set; } = WebAssemblyCultureProvider.Instance!;
-
         /// <summary>
         /// Disposes the host asynchronously.
         /// </summary>
@@ -124,7 +121,7 @@ public Task RunAsync()
         }
 
         // Internal for testing.
-        internal async Task RunAsyncCore(CancellationToken cancellationToken)
+        internal async Task RunAsyncCore(CancellationToken cancellationToken, WebAssemblyCultureProvider? cultureProvider = null)
         {
             if (_started)
             {
@@ -133,13 +130,13 @@ internal async Task RunAsyncCore(CancellationToken cancellationToken)
 
             _started = true;
 
-            CultureProvider.ThrowIfCultureChangeIsUnsupported();
+            cultureProvider ??= WebAssemblyCultureProvider.Instance!;
+            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 CultureProvider.LoadCurrentCultureResourcesAsync();
+            await cultureProvider.LoadCurrentCultureResourcesAsync();
 
             var manager = Services.GetRequiredService<ComponentApplicationLifetime>();
             var store = !string.IsNullOrEmpty(_persistedState) ?

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

@@ -36,7 +36,6 @@ public sealed class WebAssemblyHostBuilder
         /// </summary>
         /// <param name="args">The argument passed to the application's main method.</param>
         /// <returns>A <see cref="WebAssemblyHostBuilder"/>.</returns>
-        [DynamicDependency(DynamicallyAccessedMemberTypes.PublicMethods, typeof(EntrypointInvoker))]
         [DynamicDependency(DynamicallyAccessedMemberTypes.PublicMethods, typeof(JSInteropMethods))]
         [DynamicDependency(JsonSerialized, typeof(WebEventDescriptor))]
         public static WebAssemblyHostBuilder CreateDefault(string[]? args = default)
@@ -46,6 +45,8 @@ public static WebAssemblyHostBuilder CreateDefault(string[]? args = default)
             args ??= Array.Empty<string>();
             var builder = new WebAssemblyHostBuilder(DefaultWebAssemblyJSRuntime.Instance);
 
+            WebAssemblyCultureProvider.Initialize();
+
             // Right now we don't have conventions or behaviors that are specific to this method
             // however, making this the default for the template allows us to add things like that
             // in the future, while giving `new WebAssemblyHostBuilder` as an opt-out of opinionated