Changes per PR comments

Author: pranavkm

src/Components/Blazor/Blazor/src/Hosting/WebAssemblyBlazorApplicationBuilder.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Threading.Tasks;
 using Microsoft.AspNetCore.Blazor.Rendering;
 using Microsoft.AspNetCore.Components.Builder;
 
@@ -35,13 +36,13 @@ public void AddComponent(Type componentType, string domElementSelector)
             Entries.Add((componentType, domElementSelector));
         }
 
-        public WebAssemblyRenderer CreateRenderer()
+        public async Task<WebAssemblyRenderer> CreateRendererAsync()
         {
             var renderer = new WebAssemblyRenderer(Services);
             for (var i = 0; i < Entries.Count; i++)
             {
-                var entry = Entries[i];
-                renderer.AddComponent(entry.componentType, entry.domElementSelector);
+                var (componentType, domElementSelector) = Entries[i];
+                await renderer.AddComponentAsync(componentType, domElementSelector);
             }
 
             return renderer;

src/Components/Blazor/Blazor/src/Hosting/WebAssemblyHost.cs

@@ -42,6 +42,11 @@ public Task StartAsync(CancellationToken cancellationToken = default)
             JSRuntime.SetCurrentJSRuntime(_runtime);
             SetBrowserHttpMessageHandlerAsDefault();
 
+            return StartAsyncAwaited();
+        }
+
+        private async Task StartAsyncAwaited()
+        {
             var scopeFactory = Services.GetRequiredService<IServiceScopeFactory>();
             _scope = scopeFactory.CreateScope();
 
@@ -61,7 +66,7 @@ public Task StartAsync(CancellationToken cancellationToken = default)
                 var builder = new WebAssemblyBlazorApplicationBuilder(_scope.ServiceProvider);
                 startup.Configure(builder, _scope.ServiceProvider);
 
-                _renderer = builder.CreateRenderer();
+                _renderer = await builder.CreateRendererAsync();
             }
             catch
             {
@@ -76,9 +81,6 @@ public Task StartAsync(CancellationToken cancellationToken = default)
 
                 throw;
             }
-
-
-            return Task.CompletedTask;
         }
 
         public Task StopAsync(CancellationToken cancellationToken = default)

src/Components/Blazor/Blazor/src/Rendering/WebAssemblyRenderer.cs

@@ -37,19 +37,26 @@ public WebAssemblyRenderer(IServiceProvider serviceProvider): base(serviceProvid
         /// </summary>
         /// <typeparam name="TComponent">The type of the component.</typeparam>
         /// <param name="domElementSelector">A CSS selector that uniquely identifies a DOM element.</param>
-        public void AddComponent<TComponent>(string domElementSelector)
-            where TComponent: IComponent
-        {
-            AddComponent(typeof(TComponent), domElementSelector);
-        }
+        /// <returns>A <see cref="Task"/> that represents the asynchronous rendering of the added component.</returns>
+        /// <remarks>
+        /// Callers of this method may choose to ignore the returned <see cref="Task"/> if they do not
+        /// want to await the rendering of the added component.
+        /// </remarks>
+        public Task AddComponentAsync<TComponent>(string domElementSelector) where TComponent : IComponent
+            => AddComponentAsync(typeof(TComponent), domElementSelector);
 
         /// <summary>
         /// Associates the <see cref="IComponent"/> with the <see cref="WebAssemblyRenderer"/>,
         /// causing it to be displayed in the specified DOM element.
         /// </summary>
         /// <param name="componentType">The type of the component.</param>
         /// <param name="domElementSelector">A CSS selector that uniquely identifies a DOM element.</param>
-        public async void AddComponent(Type componentType, string domElementSelector)
+        /// <returns>A <see cref="Task"/> that represents the asynchronous rendering of the added component.</returns>
+        /// <remarks>
+        /// Callers of this method may choose to ignore the returned <see cref="Task"/> if they do not
+        /// want to await the rendering of the added component.
+        /// </remarks>
+        public Task AddComponentAsync(Type componentType, string domElementSelector)
         {
             var component = InstantiateComponent(componentType);
             var componentId = AssignRootComponentId(component);
@@ -65,8 +72,7 @@ public async void AddComponent(Type componentType, string domElementSelector)
                 domElementSelector,
                 componentId);
 
-            // Dispatch the rendering. In the most common cases, this will finish synchronously
-            await RenderRootComponentAsync(componentId);
+            return RenderRootComponentAsync(componentId);
         }
 
         /// <inheritdoc />

src/Components/Components/src/ComponentBase.cs

@@ -203,7 +203,16 @@ private async Task RunInitAndSetParametersAsync()
                 // async work is to be performed.
                 StateHasChanged();
 
-                await ProcessLifecycleTaskAsync(task);
+                try
+                {
+                    await task;
+                }
+                catch when (task.IsCanceled)
+                {
+                    // Ignore exceptions from task cancelletions.
+                }
+
+                // Don't call StateHasChanged here. CallOnParametersSetAsync should handle that for us.
             }
 
             await CallOnParametersSetAsync();
@@ -224,19 +233,19 @@ private Task CallOnParametersSetAsync()
             StateHasChanged();
 
             return shouldAwaitTask ?
-                ProcessLifecycleTaskAsync(task) :
+                CallStateHasChangedOnAsyncCompletion(task) :
                 Task.CompletedTask;
         }
 
-        private async Task ProcessLifecycleTaskAsync(Task task)
+        private async Task CallStateHasChangedOnAsyncCompletion(Task task)
         {
             try
             {
                 await task;
             }
             catch when (task.IsCanceled)
             {
-                // Ignore task cancelation but don't bother issuing a state change.
+                // Ignore exceptions from task cancelletions, but don't bother issuing a state change.
                 return;
             }
 
@@ -255,7 +264,7 @@ Task IHandleEvent.HandleEventAsync(EventHandlerInvoker binding, UIEventArgs args
             StateHasChanged();
 
             return shouldAwaitTask ?
-                ProcessLifecycleTaskAsync(task) :
+                CallStateHasChangedOnAsyncCompletion(task) :
                 Task.CompletedTask;
         }
 

src/Components/Components/src/Rendering/HtmlRenderer.cs

@@ -40,28 +40,6 @@ protected override Task UpdateDisplayAsync(in RenderBatch renderBatch)
             return Task.CompletedTask;
         }
 
-        /// <summary>
-        /// Renders a component into a sequence of <see cref="string"/> fragments that represent the textual representation
-        /// of the HTML produced by the component.
-        /// </summary>
-        /// <typeparam name="TComponent">The type of the <see cref="IComponent"/>.</typeparam>
-        /// <param name="initialParameters">A <see cref="ParameterCollection"/> with the initial parameters to render the component.</param>
-        /// <returns>A sequence of <see cref="string"/> fragments that represent the HTML text of the component.</returns>
-        public IEnumerable<string> RenderComponent<TComponent>(ParameterCollection initialParameters) where TComponent : IComponent
-        {
-            return RenderComponent(typeof(TComponent), initialParameters);
-        }
-
-        /// <summary>
-        /// Renders a component into a sequence of <see cref="string"/> fragments that represent the textual representation
-        /// of the HTML produced by the component.
-        /// </summary>
-        /// <param name="componentType">The type of the <see cref="IComponent"/>.</param>
-        /// <param name="initialParameters">A <see cref="ParameterCollection"/> with the initial parameters to render the component.</param>
-        /// <returns>A sequence of <see cref="string"/> fragments that represent the HTML text of the component.</returns>
-        private IEnumerable<string> RenderComponent(Type componentType, ParameterCollection initialParameters)
-            => RenderComponentAsync(componentType, initialParameters).GetAwaiter().GetResult();
-
         /// <summary>
         /// Renders a component into a sequence of <see cref="string"/> fragments that represent the textual representation
         /// of the HTML produced by the component.

src/Components/Components/src/Rendering/Renderer.cs

@@ -150,6 +150,10 @@ protected async Task RenderRootComponentAsync(int componentId, ParameterCollecti
             try
             {
                 await ProcessAsynchronousWork();
+                if (_pendingTasks.Count != 0)
+                {
+                    throw new Exception();
+                }
                 Debug.Assert(_pendingTasks.Count == 0);
             }
             finally
@@ -170,26 +174,15 @@ private async Task ProcessAsynchronousWork()
             // which might trigger further renders.
             while (_pendingTasks.Count > 0)
             {
-                Task pendingWork;
                 // Create a Task that represents the remaining ongoing work for the rendering process
-                pendingWork = Task.WhenAll(_pendingTasks);
+                var pendingWork = Task.WhenAll(_pendingTasks);
 
                 // Clear all pending work.
                 _pendingTasks.Clear();
 
                 // new work might be added before we check again as a result of waiting for all
                 // the child components to finish executing SetParametersAsync
-
-                try
-                {
-                    await pendingWork;
-                }
-                catch when (!pendingWork.IsCanceled)
-                {
-                    // await will unwrap an AggregateException and throw exactly one inner exception.
-                    // Using pendingWork.Exception gives us access to all of the exception
-                    HandleException(pendingWork.Exception);
-                }
+                await pendingWork;
             }
         }
 
@@ -343,7 +336,8 @@ internal void AddToPendingTasks(Task task)
                     {
                         return;
                     }
-                    _pendingTasks.Add(task);
+
+                    _pendingTasks.Add(GetErrorHandledTask(task));
                     break;
             }
         }
@@ -471,21 +465,13 @@ private async void InvokeRenderCompletedCalls(ArrayRange<RenderTreeDiff> updated
                     // The Task is incomplete.
                     // Queue up the task and we can inspect it later.
                     batch = batch ?? new List<Task>();
-                    batch.Add(task);
+                    batch.Add(GetErrorHandledTask(task));
                 }
             }
 
             if (batch != null)
             {
-                var aggregateTask = Task.WhenAll(batch);
-                try
-                {
-                    await aggregateTask;
-                }
-                catch when (!aggregateTask.IsCanceled)
-                {
-                    HandleException(aggregateTask.Exception);
-                }
+                await Task.WhenAll(batch);
             }
         }
 
@@ -532,6 +518,22 @@ private void RemoveEventHandlerIds(ArrayRange<int> eventHandlerIds, Task afterTa
             }
         }
 
+        private async Task GetErrorHandledTask(Task taskToHandle)
+        {
+            try
+            {
+                await taskToHandle;
+            }
+            catch (Exception ex)
+            {
+                if (!taskToHandle.IsCanceled)
+                {
+                    // Ignore errors due to task cancellations.
+                    HandleException(ex);
+                }
+            }
+        }
+
         /// <summary>
         /// Releases all resources currently used by this <see cref="Renderer"/> instance.
         /// </summary>

src/Components/Components/test/ComponentBaseTest.cs

@@ -168,10 +168,10 @@ public async Task RendersAfterParametersSetAsyncTaskIsCompleted()
             component.Counter = 2;
             parametersSetTask.SetResult(true);
 
+            await renderTask;
+
             // Component should be rendered again
             Assert.Equal(2, renderer.Batches.Count);
-
-            await renderTask;
         }
 
         [Fact]
@@ -194,26 +194,25 @@ public async Task RendersAfterParametersSetAndInitAsyncTasksAreCompleted()
             var renderTask = renderer.RenderRootComponentAsync(componentId);
 
             // Assert
+            // A rendering should have happened after the synchronous execution of Init
             Assert.Single(renderer.Batches);
 
             // Completes task started by OnInitAsync
             component.Counter = 2;
             initTask.SetResult(true);
 
-            // Component should be rendered again 2 times
-            // after on init async
-            // after set parameters
-            Assert.Equal(3, renderer.Batches.Count);
+            // Component should be rendered once, after set parameters
+            Assert.Equal(2, renderer.Batches.Count);
 
             // Completes task started by OnParametersSetAsync
             component.Counter = 3;
             parametersSetTask.SetResult(false);
 
+            await renderTask;
+
             // Component should be rendered again
             // after the async part of onparameterssetasync completes
-            Assert.Equal(4, renderer.Batches.Count);
-
-            await renderTask;
+            Assert.Equal(3, renderer.Batches.Count);
         }
 
         [Fact]
@@ -230,17 +229,18 @@ public async Task DoesNotRenderAfterOnInitAsyncTaskIsCancelled()
             var renderTask = renderer.RenderRootComponentAsync(componentId);
 
             // Assert
+            Assert.False(renderTask.IsCompleted);
             Assert.Single(renderer.Batches);
 
             // Cancel task started by OnInitAsync
             component.Counter = 2;
             initTask.SetCanceled();
 
+            await renderTask;
+
             // Component should only be rendered again due to
             // the call to StateHasChanged after SetParametersAsync
             Assert.Equal(2, renderer.Batches.Count);
-
-            await renderTask;
         }
 
         [Fact]
@@ -287,10 +287,11 @@ public async Task DoesNotRenderAfterOnParametersSetAsyncTaskIsCanceled()
             component.Counter = 2;
             onParametersSetTask.SetCanceled();
 
+            await renderTask;
+
             // Component should not be rendered again
             Assert.Single(renderer.Batches);
 
-            await renderTask;
         }
 
         [Fact]