Undo renderer changes

Author: pranavkm

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

@@ -18,8 +18,9 @@ public abstract class Renderer : IDisposable
     {
         private readonly ComponentFactory _componentFactory;
         private readonly Dictionary<int, ComponentState> _componentStateById = new Dictionary<int, ComponentState>();
+        private readonly RenderBatchBuilder _batchBuilder = new RenderBatchBuilder();
         private readonly Dictionary<int, EventCallback> _eventBindings = new Dictionary<int, EventCallback>();
-        private IDispatcher _dispatcher { get; }
+        private readonly IDispatcher _dispatcher;
 
         private int _nextComponentId = 0; // TODO: change to 'long' when Mono .NET->JS interop supports it
         private bool _isBatchInProgress;
@@ -68,8 +69,6 @@ public Renderer(IServiceProvider serviceProvider, IDispatcher dispatcher) : this
             _dispatcher = dispatcher;
         }
 
-        internal RenderBatchBuilder RenderBatchBuilder { get; } = new RenderBatchBuilder();
-
         /// <summary>
         /// Creates an <see cref="IDispatcher"/> that can be used with one or more <see cref="Renderer"/>.
         /// </summary>
@@ -388,7 +387,7 @@ protected internal virtual void AddToRenderQueue(int componentId, RenderFragment
                 return;
             }
 
-            RenderBatchBuilder.ComponentRenderQueue.Enqueue(
+            _batchBuilder.ComponentRenderQueue.Enqueue(
                 new RenderQueueEntry(componentState, renderFragment));
 
             if (!_isBatchInProgress)
@@ -420,23 +419,24 @@ private ComponentState GetRequiredComponentState(int componentId)
 
         private ComponentState GetOptionalComponentState(int componentId)
             => _componentStateById.TryGetValue(componentId, out var componentState)
-                ? componentState 
+                ? componentState
                 : null;
 
         private void ProcessRenderQueue()
         {
-            var updateDisplayTask = Task.CompletedTask;
             _isBatchInProgress = true;
+            var updateDisplayTask = Task.CompletedTask;
+
             try
             {
                 // Process render queue until empty
-                while (RenderBatchBuilder.ComponentRenderQueue.Count > 0)
+                while (_batchBuilder.ComponentRenderQueue.Count > 0)
                 {
-                    var nextToRender = RenderBatchBuilder.ComponentRenderQueue.Dequeue();
+                    var nextToRender = _batchBuilder.ComponentRenderQueue.Dequeue();
                     RenderInExistingBatch(nextToRender);
                 }
 
-                var batch = RenderBatchBuilder.ToBatch();
+                var batch = _batchBuilder.ToBatch();
                 updateDisplayTask = UpdateDisplayAsync(batch);
 
                 // Fire off the execution of OnAfterRenderAsync, but don't wait for it
@@ -445,8 +445,8 @@ private void ProcessRenderQueue()
             }
             finally
             {
-                RemoveEventHandlerIds(RenderBatchBuilder.DisposedEventHandlerIds.ToRange(), updateDisplayTask);
-                RenderBatchBuilder.Clear();
+                RemoveEventHandlerIds(_batchBuilder.DisposedEventHandlerIds.ToRange(), updateDisplayTask);
+                _batchBuilder.Clear();
                 _isBatchInProgress = false;
             }
         }
@@ -495,15 +495,15 @@ private Task InvokeRenderCompletedCalls(ArrayRange<RenderTreeDiff> updatedCompon
         private void RenderInExistingBatch(RenderQueueEntry renderQueueEntry)
         {
             renderQueueEntry.ComponentState
-                .RenderIntoBatch(RenderBatchBuilder, renderQueueEntry.RenderFragment);
+                .RenderIntoBatch(_batchBuilder, renderQueueEntry.RenderFragment);
 
             // Process disposal queue now in case it causes further component renders to be enqueued
-            while (RenderBatchBuilder.ComponentDisposalQueue.Count > 0)
+            while (_batchBuilder.ComponentDisposalQueue.Count > 0)
             {
-                var disposeComponentId = RenderBatchBuilder.ComponentDisposalQueue.Dequeue();
-                GetRequiredComponentState(disposeComponentId).DisposeInBatch(RenderBatchBuilder);
+                var disposeComponentId = _batchBuilder.ComponentDisposalQueue.Dequeue();
+                GetRequiredComponentState(disposeComponentId).DisposeInBatch(_batchBuilder);
                 _componentStateById.Remove(disposeComponentId);
-                RenderBatchBuilder.DisposedComponentIds.Append(disposeComponentId);
+                _batchBuilder.DisposedComponentIds.Append(disposeComponentId);
             }
         }
 

src/Components/Server/src/Circuits/CircuitRegistry.cs

@@ -174,9 +174,6 @@ public virtual async Task<CircuitHost> ConnectAsync(string circuitId, IClientPro
 
             await circuitHandlerTask;
 
-            // Dispatch any buffered renders we accumulated during a disconnect.
-            await circuitHost.Renderer.ProcessBufferedRenderBatches();
-
             return circuitHost;
         }
 

src/Components/Server/src/Circuits/RemoteRenderer.cs

@@ -24,6 +24,7 @@ internal class RemoteRenderer : HtmlRenderer
 
         private readonly int _id;
         private readonly IJSRuntime _jsRuntime;
+        private readonly CircuitClientProxy _client;
         private readonly RendererRegistry _rendererRegistry;
         private readonly ConcurrentDictionary<long, AutoCancelTaskCompletionSource<object>> _pendingRenders
             = new ConcurrentDictionary<long, AutoCancelTaskCompletionSource<object>>();
@@ -50,15 +51,13 @@ public RemoteRenderer(
         {
             _rendererRegistry = rendererRegistry;
             _jsRuntime = jsRuntime;
-            Client = client;
+            _client = client;
 
             _id = _rendererRegistry.Add(this);
             _logger = logger;
         }
 
-        internal ConcurrentQueue<RenderBatch> OfflineRenderBatches = new ConcurrentQueue<RenderBatch>();
-
-        internal CircuitClientProxy Client { get; }
+        internal ConcurrentQueue<byte[]> OfflineRenderBatches = new ConcurrentQueue<byte[]>();
 
         /// <summary>
         /// Associates the <see cref="IComponent"/> with the <see cref="RemoteRenderer"/>,
@@ -107,37 +106,37 @@ protected override void Dispose(bool disposing)
         /// <inheritdoc />
         protected override Task UpdateDisplayAsync(in RenderBatch batch)
         {
-            if (!Client.Connected)
+            // Note that we have to capture the data as a byte[] synchronously here, because
+            // SignalR's SendAsync can wait an arbitrary duration before serializing the params.
+            // The RenderBatch buffer will get reused by subsequent renders, so we need to
+            // snapshot its contents now.
+            // TODO: Consider using some kind of array pool instead of allocating a new
+            //       buffer on every render.
+            var batchBytes = MessagePackSerializer.Serialize(batch, RenderBatchFormatterResolver.Instance);
+
+            if (!_client.Connected)
             {
                 // Buffer the rendered batches while the client is disconnected. We'll send it down once the client reconnects.
-                OfflineRenderBatches.Enqueue(batch);
+                OfflineRenderBatches.Enqueue(batchBytes);
                 return Task.CompletedTask;
             }
 
-            Log.BeginUpdateDisplayAsync(_logger, Client.ConnectionId);
-            return WriteBatchBytes(batch);
+            Log.BeginUpdateDisplayAsync(_logger, _client.ConnectionId);
+            return WriteBatchBytes(batchBytes);
         }
 
         public async Task ProcessBufferedRenderBatches()
         {
             // The server may discover that the client disconnected while we're attempting to write empty rendered batches.
             // Discontinue writing in this event.
-            while (Client.Connected && OfflineRenderBatches.TryDequeue(out var renderBatch))
+            while (_client.Connected && OfflineRenderBatches.TryDequeue(out var renderBatch))
             {
                 await WriteBatchBytes(renderBatch);
             }
         }
 
-        private Task WriteBatchBytes(in RenderBatch renderBatch)
+        private Task WriteBatchBytes(byte[] batchBytes)
         {
-            // Note that we have to capture the data as a byte[] synchronously here, because
-            // SignalR's SendAsync can wait an arbitrary duration before serializing the params.
-            // The RenderBatch buffer will get reused by subsequent renders, so we need to
-            // snapshot its contents now.
-            // TODO: Consider using some kind of array pool instead of allocating a new
-            //       buffer on every render.
-            var batchBytes = MessagePackSerializer.Serialize(renderBatch, RenderBatchFormatterResolver.Instance);
-
             var renderId = Interlocked.Increment(ref _nextRenderId);
 
             var pendingRenderInfo = new AutoCancelTaskCompletionSource<object>(TimeoutMilliseconds);
@@ -148,7 +147,7 @@ private Task WriteBatchBytes(in RenderBatch renderBatch)
             // the whole render with that exception
             try
             {
-                Client.SendAsync("JS.RenderBatch", _id, renderId, batchBytes).ContinueWith(sendTask =>
+                _client.SendAsync("JS.RenderBatch", _id, renderId, batchBytes).ContinueWith(sendTask =>
                 {
                     if (sendTask.IsFaulted)
                     {

src/Components/Server/src/ComponentHub.cs

@@ -95,6 +95,11 @@ public async Task<bool> ConnectCircuit(string circuitId)
             if (circuitHost != null)
             {
                 CircuitHost = circuitHost;
+
+                // Dispatch any buffered renders we accumulated during a disconnect.
+                // Note that while the rendering is async, we cannot await it here. The Task returned by ProcessBufferedRenderBatches relies on
+                // OnRenderCompleted to be invoked to complete, and SignalR does not allow concurrent hub method invocations.
+                _ = circuitHost.Renderer.ProcessBufferedRenderBatches();
                 return true;
             }
 

src/Components/Server/test/Circuits/RemoteRendererTest.cs

@@ -86,7 +86,7 @@ public async Task ProcessBufferedRenderBatches_WritesRenders()
             component.TriggerRender();
 
             // Act
-            renderer.Client.Transfer(client.Object, "new-connection");
+            circuitClient.Transfer(client.Object, "new-connection");
             var task = renderer.ProcessBufferedRenderBatches();
             foreach (var id in renderIds)
             {

src/Components/test/testassets/ComponentsApp.App/Pages/FetchData.cshtml

@@ -0,0 +1,61 @@
+@page "/fetchdata"
+@page "/fetchdata/{StartDate:datetime}"
+@inject WeatherForecastService ForecastService
+
+<h1>Weather forecast</h1>
+
+<p>This component demonstrates fetching data from the server.</p>
+
+@if (forecasts == null)
+{
+    <p><em>Loading...</em></p>
+}
+else
+{
+    <table class='table'>
+        <thead>
+            <tr>
+                <th>Date</th>
+                <th>Temp. (C)</th>
+                <th>Temp. (F)</th>
+                <th>Summary</th>
+            </tr>
+        </thead>
+        <tbody>
+            @foreach (var forecast in forecasts)
+            {
+                <tr>
+                    <td>@forecast.DateFormatted</td>
+                    <td>@forecast.TemperatureC</td>
+                    <td>@forecast.TemperatureF</td>
+                    <td>@forecast.Summary</td>
+                </tr>
+            }
+        </tbody>
+    </table>
+    <p>
+        <a href="fetchdata/@StartDate.AddDays(-5).ToString("yyyy-MM-dd")" class="btn btn-secondary float-left">
+            ◀ Previous
+        </a>
+        <a href="fetchdata/@StartDate.AddDays(5).ToString("yyyy-MM-dd")" class="btn btn-secondary float-right">
+            Next ▶
+        </a>
+    </p>
+}
+
+@functions {
+    [Parameter] DateTime StartDate { get; set; }
+
+    WeatherForecast[] forecasts;
+
+    public override Task SetParametersAsync(ParameterCollection parameters)
+    {
+        StartDate = DateTime.Now;
+        return base.SetParametersAsync(parameters);
+    }
+
+    protected override async Task OnParametersSetAsync()
+    {
+        forecasts = await ForecastService.GetForecastAsync(StartDate);
+    }
+}