Spurce up API and add tests for pre-rendering scenario

Author: captainsafia

src/Components/Components/ref/Microsoft.AspNetCore.Components.netcoreapp.cs

@@ -246,10 +246,6 @@ public partial interface IHandleEvent
     {
         System.Threading.Tasks.Task HandleEventAsync(Microsoft.AspNetCore.Components.EventCallbackWorkItem item, object? arg);
     }
-    public partial interface ILazyLoader
-    {
-        System.Threading.Tasks.Task<System.Collections.Generic.IEnumerable<System.Reflection.Assembly>> LoadAssembliesAsync(System.Collections.Generic.IEnumerable<string> assembliesToLoad);
-    }
     [System.AttributeUsageAttribute(System.AttributeTargets.Property, AllowMultiple=false, Inherited=true)]
     public sealed partial class InjectAttribute : System.Attribute
     {
@@ -560,9 +556,9 @@ public LocationChangedEventArgs(string location, bool isNavigationIntercepted) {
         public bool IsNavigationIntercepted { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
         public string Location { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
     }
-    public partial class OnNavigateArgs
+    public partial class NavigationContext
     {
-        public OnNavigateArgs(string path, System.Threading.CancellationTokenSource cancellationTokenSource) { }
+        internal NavigationContext() { }
         public System.Threading.CancellationTokenSource CancellationTokenSource { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
         public string Path { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
     }
@@ -576,11 +572,11 @@ public Router() { }
         [Microsoft.AspNetCore.Components.ParameterAttribute]
         public Microsoft.AspNetCore.Components.RenderFragment<Microsoft.AspNetCore.Components.RouteData> Found { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute] set { } }
         [Microsoft.AspNetCore.Components.ParameterAttribute]
-        public Microsoft.AspNetCore.Components.RenderFragment Loading { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute] set { } }
+        public Microsoft.AspNetCore.Components.RenderFragment Navigating { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute] set { } }
         [Microsoft.AspNetCore.Components.ParameterAttribute]
         public Microsoft.AspNetCore.Components.RenderFragment NotFound { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute] set { } }
         [Microsoft.AspNetCore.Components.ParameterAttribute]
-        public System.Func<Microsoft.AspNetCore.Components.Routing.OnNavigateArgs, System.Threading.Tasks.Task> OnNavigateAsync { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute] set { } }
+        public System.Func<Microsoft.AspNetCore.Components.Routing.NavigationContext, System.Threading.Tasks.Task> OnNavigateAsync { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute] set { } }
         public void Attach(Microsoft.AspNetCore.Components.RenderHandle renderHandle) { }
         public void Dispose() { }
         System.Threading.Tasks.Task Microsoft.AspNetCore.Components.IHandleAfterRender.OnAfterRenderAsync() { throw null; }

src/Components/Components/src/ILazyLoader.cs

@@ -10,9 +10,9 @@
 
 namespace Microsoft.AspNetCore.Components.Routing
 {
-    public class OnNavigateArgs
+    public class NavigationContext
     {
-        public OnNavigateArgs(string path, CancellationTokenSource cancellationTokenSource)
+        internal NavigationContext(string path, CancellationTokenSource cancellationTokenSource)
         {
             Path = path;
             CancellationTokenSource = cancellationTokenSource;

src/Components/Components/src/Routing/OnNavigateArgs.cs renamed to src/Components/Components/src/Routing/NavigationContext.cs

@@ -62,14 +62,14 @@ static readonly ReadOnlyDictionary<string, object> _emptyParametersDictionary
         [Parameter] public RenderFragment<RouteData> Found { get; set; }
 
         /// <summary>
-        /// Get or sets the content to display when the upcoming route is loading.
+        /// Get or sets the content to display when asynchronous navigation is in progress.
         /// </summary>
-        [Parameter] public RenderFragment Loading { get; set; }
+        [Parameter] public RenderFragment Navigating { get; set; }
 
         /// <summary>
         /// Gets or sets a handler that should be called before navigating to a new page.
         /// </summary>
-        [Parameter] public Func<OnNavigateArgs, Task> OnNavigateAsync { get; set; }
+        [Parameter] public Func<NavigationContext, Task> OnNavigateAsync { get; set; }
 
         private RouteTable Routes { get; set; }
 
@@ -134,6 +134,18 @@ private void RefreshRouteTable()
                 Routes = RouteTableFactory.Create(assemblies);
                 _assemblies = assembliesSet;
             }
+            // If the new assemblies set is the same length as the previous one,
+            // we check if they are equal-by-value and refresh the route table if
+            // not. NOTE: This is an uncommon occurrence and a cold-code path so
+            // we shouldn't end up needing to do an equal-by-value check too frequently.
+            if (_assemblies.Count == assembliesSet.Count)
+            {
+                if (!_assemblies.SetEquals(assembliesSet))
+                {
+                    Routes = RouteTableFactory.Create(assemblies);
+                    _assemblies = assembliesSet;
+                }
+            }
         }
 
         private void Refresh(bool isNavigationIntercepted)
@@ -189,32 +201,28 @@ private async Task RunOnNavigateAsync(string path, bool isNavigationIntercepted)
                 return;
             }
 
-            // Create a new CTS for this invocation of the task and
-            // extract the reference to the current one.
-            var pendingOnNavigateCts = _onNavigateCts;
-            var onNavigateCts = new CancellationTokenSource();
-            _onNavigateCts = onNavigateCts;
-
-            var navigateContext = new OnNavigateArgs(path, _onNavigateCts);
-            var task = OnNavigateAsync(navigateContext);
-
             // If we've already invoked a task and stored its CTS, then
             // cancel the existing task.
-            if (pendingOnNavigateCts != null)
+            if (_onNavigateCts != null && !_onNavigateCts.IsCancellationRequested)
             {
-                pendingOnNavigateCts.Cancel();
+                _onNavigateCts.Cancel();
             }
+            // Create a new cancellation token source for this instance
+            _onNavigateCts = new CancellationTokenSource();
+
+            var navigateContext = new NavigationContext(path, _onNavigateCts);
+            var task = OnNavigateAsync(navigateContext);
 
             // Create a cancellation task based on the cancellation token
             // associated with the current running task.
             var cancellationTaskSource = new TaskCompletionSource();
             navigateContext.CancellationTokenSource.Token.Register(() =>
                 cancellationTaskSource.TrySetCanceled(navigateContext.CancellationTokenSource.Token));
 
-            // If the user provided a Loading render fragment, then show it.
-            if (Loading != null)
+            // If the user provided a Navigating render fragment, then show it.
+            if (Navigating != null && task.Status != TaskStatus.RanToCompletion)
             {
-                _renderHandle.Render(Loading);
+                _renderHandle.Render(Navigating);
             }
 
             await Task.WhenAny(task, cancellationTaskSource.Task);

src/Components/Components/src/Routing/Router.cs

@@ -41,11 +41,6 @@ public ServerAuthenticationStateProvider() { }
         public override System.Threading.Tasks.Task<Microsoft.AspNetCore.Components.Authorization.AuthenticationState> GetAuthenticationStateAsync() { throw null; }
         public void SetAuthenticationState(System.Threading.Tasks.Task<Microsoft.AspNetCore.Components.Authorization.AuthenticationState> authenticationStateTask) { }
     }
-    public partial class ServerLazyAssemblyLoader : Microsoft.AspNetCore.Components.ILazyLoader
-    {
-        public ServerLazyAssemblyLoader() { }
-        public System.Threading.Tasks.Task<System.Collections.Generic.IEnumerable<System.Reflection.Assembly>> LoadAssembliesAsync(System.Collections.Generic.IEnumerable<string> assembliesToLoad) { throw null; }
-    }
 }
 namespace Microsoft.AspNetCore.Components.Server.Circuits
 {

src/Components/Server/ref/Microsoft.AspNetCore.Components.Server.netcoreapp.cs

@@ -74,7 +74,6 @@ public static IServerSideBlazorBuilder AddServerSideBlazor(this IServiceCollecti
             services.AddScoped<IJSRuntime, RemoteJSRuntime>();
             services.AddScoped<INavigationInterception, RemoteNavigationInterception>();
             services.AddScoped<AuthenticationStateProvider, ServerAuthenticationStateProvider>();
-            services.TryAddSingleton<ILazyLoader, ServerLazyAssemblyLoader>();
 
             services.TryAddEnumerable(ServiceDescriptor.Singleton<IConfigureOptions<CircuitOptions>, CircuitOptionsJSInteropDetailedErrorsConfiguration>());
 

src/Components/Server/src/Circuits/ServerLazyAssemblyLoader.cs

@@ -191,7 +191,6 @@ internal void InitializeDefaultServices()
             Services.AddSingleton<IJSRuntime>(DefaultWebAssemblyJSRuntime.Instance);
             Services.AddSingleton<NavigationManager>(WebAssemblyNavigationManager.Instance);
             Services.AddSingleton<INavigationInterception>(WebAssemblyNavigationInterception.Instance);
-            Services.AddSingleton<ILazyLoader>(new WebAssemblyLazyAssemblyLoader(DefaultWebAssemblyJSRuntime.Instance));
             Services.AddLogging(builder => {
                 builder.AddProvider(new WebAssemblyConsoleLoggerProvider(DefaultWebAssemblyJSRuntime.Instance));
             });

src/Components/Server/src/DependencyInjection/ComponentServiceCollectionExtensions.cs

@@ -7,32 +7,60 @@
 using System.Linq;
 using System.Reflection;
 using System.Threading.Tasks;
+using System.Runtime.InteropServices;
 using System.Runtime.Loader;
 using Microsoft.JSInterop.WebAssembly;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.JSInterop;
 
-namespace Microsoft.AspNetCore.Components.WebAssembly
+namespace Microsoft.AspNetCore.Components.WebAssembly.Services
 {
-    public class WebAssemblyLazyAssemblyLoader : ILazyLoader
+    public class LazyAssemblyLoader
     {
         internal const string GetDynamicAssemblies = "window.Blazor._internal.getLazyAssemblies";
         internal const string ReadDynamicAssemblies = "window.Blazor._internal.readLazyAssemblies";
 
         private List<string> _loadedAssemblyCache = new List<string>();
 
-        private readonly WebAssemblyJSRuntime _jsRuntime;
+        private readonly IServiceProvider _provider;
 
-        internal WebAssemblyLazyAssemblyLoader(WebAssemblyJSRuntime jsRuntime)
+        public LazyAssemblyLoader(IServiceProvider provider)
         {
-            _jsRuntime = jsRuntime;
+            _provider = provider;
         }
 
         public async Task<IEnumerable<Assembly>> LoadAssembliesAsync(IEnumerable<string> assembliesToLoad)
         {
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Browser))
+            {
+                return await LoadAssembliesInClientAsync(assembliesToLoad);
+            }
+
+            return await LoadAssembliesInServerAsync(assembliesToLoad);
+        }
+
+        private Task<IEnumerable<Assembly>> LoadAssembliesInServerAsync(IEnumerable<string> assembliesToLoad)
+        {
+            var assemblies = AppDomain.CurrentDomain.GetAssemblies().Where(assembly =>
+                assembliesToLoad.Contains(assembly.GetName().Name + ".dll"));
+
+            if (assemblies.Count() != assembliesToLoad.Count())
+            {
+                var unloadedAssemblies = assembliesToLoad.Except(assemblies.Select(assembly => assembly.GetName().Name + ".dll"));
+                throw new FileNotFoundException($"Unable to find the following assemblies: {string.Join(",", unloadedAssemblies)}");
+            }
+
+            return Task.FromResult(assemblies);
+        }
+
+        private async Task<IEnumerable<Assembly>> LoadAssembliesInClientAsync(IEnumerable<string> assembliesToLoad)
+        {
+            var _jsRuntime = _provider.GetRequiredService<IJSRuntime>();
             // Only load assemblies that haven't already been lazily-loaded
             var newAssembliesToLoad = assembliesToLoad.Where(assembly => !_loadedAssemblyCache.Contains(assembly));
             var loadedAssemblies = new List<Assembly>();
 
-            var count = (int)await _jsRuntime.InvokeUnmarshalled<string[], object, object, Task<object>>(
+            var count = (int)await ((WebAssemblyJSRuntime)_jsRuntime).InvokeUnmarshalled<string[], object, object, Task<object>>(
                 GetDynamicAssemblies,
                 assembliesToLoad.ToArray(),
                 null,
@@ -43,7 +71,7 @@ public async Task<IEnumerable<Assembly>> LoadAssembliesAsync(IEnumerable<string>
                 return loadedAssemblies;
             }
 
-            var assemblies = _jsRuntime.InvokeUnmarshalled<object, object, object, object[]>(
+            var assemblies = ((WebAssemblyJSRuntime)_jsRuntime).InvokeUnmarshalled<object, object, object, object[]>(
                 ReadDynamicAssemblies,
                 null,
                 null,

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

@@ -60,6 +60,18 @@ public void CanUseJSInteropFromOnAfterRenderAsync()
             Browser.Equal("Hello from interop call", () => Browser.FindElement(By.Id("val-set-by-interop")).GetAttribute("value"));
         }
 
+        [Fact]
+        public void IsCompatibleWithLazyLoadWebAssembly()
+        {
+            Navigate("/prerendered/WithLazyAssembly");
+
+            var button = Browser.FindElement(By.Id("use-package-button"));
+
+            button.Click();
+
+            AssertLogDoesNotContainCriticalMessages("Could not load file or assembly 'Newtonsoft.Json");
+        }
+
         [Fact]
         public void CanReadUrlHashOnlyOnceConnected()
         {
@@ -121,6 +133,19 @@ private void BeginInteractivity()
             Browser.FindElement(By.Id("load-boot-script")).Click();
         }
 
+        private void AssertLogDoesNotContainCriticalMessages(params string[] messages)
+        {
+            var log = Browser.Manage().Logs.GetLog(LogType.Browser);
+            foreach (var message in messages)
+            {
+                Assert.DoesNotContain(log, entry =>
+                {
+                    return entry.Level == LogLevel.Severe
+                    && entry.Message.Contains(message);
+                });
+            }
+        }
+
         private void SignInAs(string userName, string roles, bool useSeparateTab = false) =>
             Browser.SignInAs(new Uri(_serverFixture.RootUri, "/prerendered/"), userName, roles, useSeparateTab);
     }

src/Components/WebAssembly/WebAssembly/src/Services/WebAssemblyLazyAssemblyLoader.cs renamed to src/Components/WebAssembly/WebAssembly/src/Services/LazyAssemblyLoader.cs

@@ -1,14 +1,15 @@
-@using Microsoft.AspNetCore.Components.Routing
+@using Microsoft.AspNetCore.Components.Routing
 @using System.Reflection
+@using Microsoft.AspNetCore.Components.WebAssembly.Services 
 
-@inject ILazyLoader lazyLoader
+@inject LazyAssemblyLoader lazyLoader
 
 <Router AppAssembly="@typeof(BasicTestApp.Program).Assembly" AdditionalAssemblies="@lazyLoadedAssemblies" OnNavigateAsync="@OnNavigateAsync">
-    <Loading>
+    <Navigating>
         <div style="padding: 20px;background-color:blue;color:white;" id="loading-banner">
             <p>Loading the requested page...</p>
         </div>
-    </Loading>
+    </Navigating>
     <Found Context="routeData">
         <RouteView RouteData="@routeData" />
     </Found>
@@ -22,7 +23,7 @@
 @code {
     private List<Assembly> lazyLoadedAssemblies = new List<Assembly>();
 
-    private async Task OnNavigateAsync(OnNavigateArgs args)
+    private async Task OnNavigateAsync(NavigationContext args)
     {
         Console.WriteLine($"Running OnNavigate for {args.Path}...");
         await LoadAssemblies(args.Path);

src/Components/test/E2ETest/ServerExecutionTests/PrerenderingTest.cs

@@ -1,11 +1,11 @@
-@using Microsoft.AspNetCore.Components.Routing
+@using Microsoft.AspNetCore.Components.Routing
 
 <Router AppAssembly="@typeof(BasicTestApp.Program).Assembly" OnNavigateAsync="@OnNavigateAsync">
-    <Loading>
+    <Navigating>
         <div style="padding: 20px;background-color:blue;color:white;" id="loading-banner">
             <p>Loading the requested page...</p>
         </div>
-    </Loading>
+    </Navigating>
     <Found Context="routeData">
         <RouteView RouteData="@routeData" />
     </Found>
@@ -17,28 +17,28 @@
 </Router>
 
 @code {
-    private Dictionary<string, Func<OnNavigateArgs, Task>> preNavigateTasks = new Dictionary<string, Func<OnNavigateArgs, Task>>()
+    private Dictionary<string, Func<NavigationContext, Task>> preNavigateTasks = new Dictionary<string, Func<NavigationContext, Task>>()
     {
-        { "LongPage1", new Func<OnNavigateArgs, Task>(TestLoadingPageShows) },
-        { "LongPage2", new Func<OnNavigateArgs, Task>(TestOnNavCancel) }
+        { "LongPage1", new Func<NavigationContext, Task>(TestLoadingPageShows) },
+        { "LongPage2", new Func<NavigationContext, Task>(TestOnNavCancel) }
     };
 
-    private async Task OnNavigateAsync(OnNavigateArgs args)
+    private async Task OnNavigateAsync(NavigationContext args)
     {
         Console.WriteLine($"Running OnNavigate for {args.Path}...");
-        Func<OnNavigateArgs, Task> task;
+        Func<NavigationContext, Task> task;
         if (preNavigateTasks.TryGetValue(args.Path, out task))
         {
             await task.Invoke(args);
         }
     }
 
-    public static async Task TestLoadingPageShows(OnNavigateArgs args)
+    public static async Task TestLoadingPageShows(NavigationContext args)
     {
         await Task.Delay(2000);
     }
 
-    public static async Task TestOnNavCancel(OnNavigateArgs args)
+    public static async Task TestOnNavCancel(NavigationContext args)
     {
         await Task.Delay(2000, args.CancellationTokenSource.Token);
         Console.WriteLine("I'm not happening...");