Add API to Renderer to trigger a UI refresh on hot reload

src/Components/Components/src/ComponentBase.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Threading.Tasks;
+using Microsoft.AspNetCore.Components.HotReload;
 using Microsoft.AspNetCore.Components.Rendering;
 
 namespace Microsoft.AspNetCore.Components
@@ -21,14 +22,15 @@ namespace Microsoft.AspNetCore.Components
     /// Optional base class for components. Alternatively, components may
     /// implement <see cref="IComponent"/> directly.
     /// </summary>
-    public abstract class ComponentBase : IComponent, IHandleEvent, IHandleAfterRender
+    public abstract class ComponentBase : IComponent, IHandleEvent, IHandleAfterRender, IReceiveHotReloadContext
     {
         private readonly RenderFragment _renderFragment;
         private RenderHandle _renderHandle;
         private bool _initialized;
         private bool _hasNeverRendered = true;
         private bool _hasPendingQueuedRender;
         private bool _hasCalledOnAfterRender;
+        private HotReloadContext? _hotReloadContext;
 
         /// <summary>
         /// Constructs an instance of <see cref="ComponentBase"/>.
@@ -102,7 +104,7 @@ protected void StateHasChanged()
                 return;
             }
 
-            if (_hasNeverRendered || ShouldRender())
+            if (_hasNeverRendered || ShouldRender() || (_hotReloadContext?.IsHotReloading ?? false))
             {
                 _hasPendingQueuedRender = true;
 
@@ -329,5 +331,10 @@ Task IHandleAfterRender.OnAfterRenderAsync()
             // have to use "async void" and do their own exception handling in
             // the case where they want to start an async task.
         }
+
+        void IReceiveHotReloadContext.Receive(HotReloadContext context)
+        {
+            _hotReloadContext = context;
+        }
     }
 }

src/Components/Components/src/HotReload/HotReloadContext.cs

@@ -0,0 +1,16 @@
+// 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.
+
+namespace Microsoft.AspNetCore.Components.HotReload
+{
+    /// <summary>
+    /// A context that indicates when a component is being rendered after a hot reload is applied to the application.
+    /// </summary>
+    public sealed class HotReloadContext
+    {
+        /// <summary>
+        /// Gets a value that indicates if the application is re-rendering in response to a hot-reload change.
+        /// </summary>
+        public bool IsHotReloading { get; internal set; }
+    }
+}

src/Components/Components/src/HotReload/HotReloadEnvironment.cs

@@ -0,0 +1,22 @@
+// 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;
+
+namespace Microsoft.AspNetCore.Components.HotReload
+{
+    internal class HotReloadEnvironment
+    {
+        public static readonly HotReloadEnvironment Instance = new(Environment.GetEnvironmentVariable("DOTNET_MODIFIABLE_ASSEMBLIES") == "debug");
+
+        public HotReloadEnvironment(bool isHotReloadEnabled)
+        {
+            IsHotReloadEnabled = isHotReloadEnabled;
+        }
+
+        /// <summary>
+        /// Gets a value that determines if HotReload is configured for this application.
+        /// </summary>
+        public bool IsHotReloadEnabled { get; }
+    }
+}

src/Components/Components/src/HotReload/HotReloadManager.cs

@@ -0,0 +1,20 @@
+// 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.Reflection;
+
+[assembly: AssemblyMetadata("ReceiveHotReloadDeltaNotification", "Microsoft.AspNetCore.Components.HotReload.HotReloadManager")]
+
+namespace Microsoft.AspNetCore.Components.HotReload
+{
+    internal static class HotReloadManager
+    {
+       internal static event Action? OnDeltaApplied;
+
+        public static void DeltaApplied()
+        {
+            OnDeltaApplied?.Invoke();
+        }
+    }
+}

src/Components/Components/src/HotReload/IReceiveHotReloadContext.cs

@@ -0,0 +1,17 @@
+// 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.
+
+namespace Microsoft.AspNetCore.Components.HotReload
+{
+    /// <summary>
+    /// Allows a component to receive a <see cref="HotReloadContext"/>.
+    /// </summary>
+    public interface IReceiveHotReloadContext : IComponent
+    {
+        /// <summary>
+        /// Configures a component to use the hot reload context.
+        /// </summary>
+        /// <param name="context"></param>
+        void Receive(HotReloadContext context);
+    }
+}

src/Components/Components/src/Microsoft.AspNetCore.Components.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFramework>$(DefaultNetCoreTargetFramework)</TargetFramework>
@@ -33,6 +33,10 @@
     <SuppressBaselineReference Include="Microsoft.JSInterop" Condition=" '$(AspNetCoreMajorMinorVersion)' == '6.0' " />
   </ItemGroup>
 
+  <ItemGroup>
+    <EmbeddedResource Include="Properties\ILLink.Substitutions.xml" LogicalName="ILLink.Substitutions.xml" />
+  </ItemGroup>
+
   <Target Name="_GetNuspecDependencyPackageVersions">
     <MSBuild Targets="_GetPackageVersionInfo"
         BuildInParallel="$(BuildInParallel)"
@@ -60,5 +64,6 @@
     <NuspecProperty Include="OutputPath=$(OutputPath)" />
     <NuspecProperty Include="PackageThirdPartyNoticesFile=$(PackageThirdPartyNoticesFile)" />
   </ItemGroup>
+
 
 </Project>

src/Components/Components/src/ParameterView.cs

@@ -116,6 +116,17 @@ public IReadOnlyDictionary<string, object> ToDictionary()
             return result;
         }
 
+        internal ParameterView Clone()
+        {
+            if (ReferenceEquals(_frames, _emptyFrames))
+            {
+                return Empty;
+            }
+
+            var dictionary = ToDictionary();
+            return FromDictionary((IDictionary<string, object?>)dictionary);
+        }
+
         internal ParameterView WithCascadingParameters(IReadOnlyList<CascadingParameterState> cascadingParameters)
             => new ParameterView(_lifetime, _frames, _ownerIndex, cascadingParameters);
 

src/Components/Components/src/Properties/AssemblyInfo.cs

@@ -8,5 +8,6 @@
 [assembly: InternalsVisibleTo("Microsoft.AspNetCore.Components.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f33a29044fa9d740c9b3213a93e57c84b472c84e0b8a0e1ae48e67a9f8f6de9d5f7f3d52ac23e48ac51801f1dc950abe901da34d2a9e3baadb141a17c77ef3c565dd5ee5054b91cf63bb3c6ab83f72ab3aafe93d0fc3c2348b764fafb0b1c0733de51459aeab46580384bf9d74c4e28164b7cde247f891ba07891c9d872ad2bb")]
 [assembly: InternalsVisibleTo("Microsoft.AspNetCore.Components.Web.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f33a29044fa9d740c9b3213a93e57c84b472c84e0b8a0e1ae48e67a9f8f6de9d5f7f3d52ac23e48ac51801f1dc950abe901da34d2a9e3baadb141a17c77ef3c565dd5ee5054b91cf63bb3c6ab83f72ab3aafe93d0fc3c2348b764fafb0b1c0733de51459aeab46580384bf9d74c4e28164b7cde247f891ba07891c9d872ad2bb")]
 [assembly: InternalsVisibleTo("Microsoft.AspNetCore.Components.ProtectedBrowserStorage.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f33a29044fa9d740c9b3213a93e57c84b472c84e0b8a0e1ae48e67a9f8f6de9d5f7f3d52ac23e48ac51801f1dc950abe901da34d2a9e3baadb141a17c77ef3c565dd5ee5054b91cf63bb3c6ab83f72ab3aafe93d0fc3c2348b764fafb0b1c0733de51459aeab46580384bf9d74c4e28164b7cde247f891ba07891c9d872ad2bb")]
+[assembly: InternalsVisibleTo("Components.TestServer, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f33a29044fa9d740c9b3213a93e57c84b472c84e0b8a0e1ae48e67a9f8f6de9d5f7f3d52ac23e48ac51801f1dc950abe901da34d2a9e3baadb141a17c77ef3c565dd5ee5054b91cf63bb3c6ab83f72ab3aafe93d0fc3c2348b764fafb0b1c0733de51459aeab46580384bf9d74c4e28164b7cde247f891ba07891c9d872ad2bb")]
 
 [assembly: InternalsVisibleTo("DynamicProxyGenAssembly2, PublicKey=0024000004800000940000000602000000240000525341310004000001000100c547cac37abd99c8db225ef2f6c8a3602f3b3606cc9891605d02baa56104f4cfc0734aa39b93bf7852f7d9266654753cc297e7d2edfe0bac1cdcf9f717241550e0a7b191195b7667bb4f64bcb8e2121380fd1d9d46ad2d92d2d15605093924cceaf74c4861eff62abf69b9291ed0a340e113be11e6a7d3113e92484cf7045cc7")]

src/Components/Components/src/Properties/ILLink.Substitutions.xml

@@ -0,0 +1,12 @@
+<linker>
+  <assembly fullname="Microsoft.AspNetCore.Components" >
+    <!-- Trim away hot-reload -->
+    <type fullname="Microsoft.AspNetCore.Components.HotReload.HotReloadEnvironment">
+      <method signature="System.Boolean get_IsHotReloadEnabled()" body="stub" value="false" />
+    </type>
+    <type fullname="Microsoft.AspNetCore.Components.HotReload.HotReloadContext">
+      <method signature="System.Boolean get_IsHotReloading()" body="stub" value="false" />
+      <method signature="System.Void set_IsHotReloading(System.Boolean)" body="remove" />
+    </type>
+  </assembly>
+</linker>

src/Components/Components/src/PublicAPI.Unshipped.txt

@@ -8,6 +8,11 @@ Microsoft.AspNetCore.Components.ComponentApplicationState.PersistAsJson<TValue>(
 Microsoft.AspNetCore.Components.ComponentApplicationState.PersistState(string! key, byte[]! value) -> void
 Microsoft.AspNetCore.Components.ComponentApplicationState.TryTakeAsJson<TValue>(string! key, out TValue? instance) -> bool
 Microsoft.AspNetCore.Components.ComponentApplicationState.TryTakePersistedState(string! key, out byte[]? value) -> bool
+Microsoft.AspNetCore.Components.HotReload.HotReloadContext
+Microsoft.AspNetCore.Components.HotReload.HotReloadContext.HotReloadContext() -> void
+Microsoft.AspNetCore.Components.HotReload.HotReloadContext.IsHotReloading.get -> bool
+Microsoft.AspNetCore.Components.HotReload.IReceiveHotReloadContext
+Microsoft.AspNetCore.Components.HotReload.IReceiveHotReloadContext.Receive(Microsoft.AspNetCore.Components.HotReload.HotReloadContext! context) -> void
 Microsoft.AspNetCore.Components.Lifetime.ComponentApplicationLifetime
 Microsoft.AspNetCore.Components.Lifetime.ComponentApplicationLifetime.ComponentApplicationLifetime(Microsoft.Extensions.Logging.ILogger<Microsoft.AspNetCore.Components.Lifetime.ComponentApplicationLifetime!>! logger) -> void
 Microsoft.AspNetCore.Components.Lifetime.ComponentApplicationLifetime.PersistStateAsync(Microsoft.AspNetCore.Components.Lifetime.IComponentApplicationStateStore! store, Microsoft.AspNetCore.Components.RenderTree.Renderer! renderer) -> System.Threading.Tasks.Task!

src/Components/Components/src/RenderTree/RenderTreeDiffBuilder.cs

@@ -535,10 +535,15 @@ private static void UpdateRetainedChildComponent(
             // comparisons it wants with the old values. Later we could choose to pass the
             // old parameter values if we wanted. By default, components always rerender
             // after any SetParameters call, which is safe but now always optimal for perf.
+
+            // When performing hot reload, we want to force all components to re-render.
+            // We do this using two mechanisms - we call SetParametersAsync even if the parameters
+            // are unchanged and we ignore ComponentBase.ShouldRender
+
             var oldParameters = new ParameterView(ParameterViewLifetime.Unbound, oldTree, oldComponentIndex);
             var newParametersLifetime = new ParameterViewLifetime(diffContext.BatchBuilder);
             var newParameters = new ParameterView(newParametersLifetime, newTree, newComponentIndex);
-            if (!newParameters.DefinitelyEquals(oldParameters))
+            if (!newParameters.DefinitelyEquals(oldParameters) || diffContext.Renderer.HotReloadContext.IsHotReloading)
             {
                 componentState.SetDirectParameters(newParameters);
             }
@@ -696,8 +701,8 @@ private static void AppendDiffEntriesForFramesWithSameSequence(
                         break;
                     }
 
-                    // We don't handle attributes here, they have their own diff logic.
-                    // See AppendDiffEntriesForAttributeFrame
+                // We don't handle attributes here, they have their own diff logic.
+                // See AppendDiffEntriesForAttributeFrame
                 default:
                     throw new NotImplementedException($"Encountered unsupported frame type during diffing: {newTree[newFrameIndex].FrameTypeField}");
             }

src/Components/Components/src/RenderTree/Renderer.cs

@@ -9,6 +9,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.AspNetCore.Components.HotReload;
 using Microsoft.AspNetCore.Components.Rendering;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
@@ -32,6 +33,8 @@ public abstract partial class Renderer : IDisposable, IAsyncDisposable
         private readonly Dictionary<ulong, ulong> _eventHandlerIdReplacements = new Dictionary<ulong, ulong>();
         private readonly ILogger<Renderer> _logger;
         private readonly ComponentFactory _componentFactory;
+        private readonly HotReloadEnvironment _hotReloadEnvironment;
+        private List<(ComponentState, ParameterView)>? _rootComponents;
 
         private int _nextComponentId = 0; // TODO: change to 'long' when Mono .NET->JS interop supports it
         private bool _isBatchInProgress;
@@ -92,6 +95,10 @@ public Renderer(IServiceProvider serviceProvider, ILoggerFactory loggerFactory,
             _serviceProvider = serviceProvider;
             _logger = loggerFactory.CreateLogger<Renderer>();
             _componentFactory = new ComponentFactory(componentActivator);
+
+            _hotReloadEnvironment = serviceProvider.GetService<HotReloadEnvironment>() ?? HotReloadEnvironment.Instance;
+
+            HotReloadManager.OnDeltaApplied += RenderRootComponentsOnHotReload;
         }
 
         private static IComponentActivator GetComponentActivatorOrDefault(IServiceProvider serviceProvider)
@@ -101,7 +108,7 @@ private static IComponentActivator GetComponentActivatorOrDefault(IServiceProvid
         }
 
         /// <summary>
-        /// Gets the <see cref="Microsoft.AspNetCore.Components.Dispatcher" /> associated with this <see cref="Renderer" />.
+        /// Gets the <see cref="Components.Dispatcher" /> associated with this <see cref="Renderer" />.
         /// </summary>
         public abstract Dispatcher Dispatcher { get; }
 
@@ -111,13 +118,49 @@ private static IComponentActivator GetComponentActivatorOrDefault(IServiceProvid
         /// </summary>
         protected internal ElementReferenceContext? ElementReferenceContext { get; protected set; }
 
+        internal HotReloadContext HotReloadContext { get; } = new();
+
+        private async void RenderRootComponentsOnHotReload()
+        {
+            await Dispatcher.InvokeAsync(async () =>
+            {
+                Debug.Assert(_rootComponents is not null);
+                HotReloadContext.IsHotReloading = true;
+
+                try
+                {
+                    _pendingTasks = new List<Task>();
+                    foreach (var (componentState, initialParameters) in _rootComponents)
+                    {
+                        AddToPendingTasks(componentState.Component.SetParametersAsync(initialParameters));
+                    }
+
+                    await ProcessAsynchronousWork();
+                    Debug.Assert(_pendingTasks.Count == 0);
+                }
+                finally
+                {
+                    _pendingTasks = null;
+                    HotReloadContext.IsHotReloading = false;
+                }
+            });
+        }
+
         /// <summary>
         /// Constructs a new component of the specified type.
         /// </summary>
         /// <param name="componentType">The type of the component to instantiate.</param>
         /// <returns>The component instance.</returns>
         protected IComponent InstantiateComponent([DynamicallyAccessedMembers(Component)] Type componentType)
-            => _componentFactory.InstantiateComponent(_serviceProvider, componentType);
+        {
+            var component = _componentFactory.InstantiateComponent(_serviceProvider, componentType);
+            if (_hotReloadEnvironment.IsHotReloadEnabled && component is IReceiveHotReloadContext receiveHotReloadContext)
+            {
+                receiveHotReloadContext.Receive(HotReloadContext);
+            }
+
+            return component;
+        }
 
         /// <summary>
         /// Associates the <see cref="IComponent"/> with the <see cref="Renderer"/>, assigning
@@ -182,6 +225,14 @@ protected async Task RenderRootComponentAsync(int componentId, ParameterView ini
             // During the asynchronous rendering process we want to wait up until all components have
             // finished rendering so that we can produce the complete output.
             var componentState = GetRequiredComponentState(componentId);
+            if (_hotReloadEnvironment.IsHotReloadEnabled)
+            {
+                // when we're doing hot-reload, stash away the parameters used while rendering root components.
+                // We'll use this to trigger re-renders on hot reload updates.
+                _rootComponents ??= new();
+                _rootComponents.Add((componentState, initialParameters.Clone()));
+            }
+
             componentState.SetDirectParameters(initialParameters);
 
             try
@@ -884,6 +935,8 @@ public void Dispose()
         /// <inheritdoc />
         public async ValueTask DisposeAsync()
         {
+            HotReloadManager.OnDeltaApplied -= RenderRootComponentsOnHotReload;
+
             if (_disposed)
             {
                 return;

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

@@ -38,6 +38,10 @@ async function boot(options?: Partial<WebAssemblyStartOptions>): Promise<void> {
 
   Blazor._internal.InputFile = WasmInputFile;
 
+  Blazor._internal.applyHotReload = (id: string, metadataDelta: string, ilDeta: string) => {
+    DotNet.invokeMethod('Microsoft.AspNetCore.Components.WebAssembly', 'ApplyHotReloadDelta', id, metadataDelta, ilDeta);
+  };
+
   // Configure JS interop
   Blazor._internal.invokeJSFromDotNet = invokeJSFromDotNet;
 

src/Components/Web.JS/src/GlobalExports.ts

@@ -45,7 +45,8 @@ interface IBlazor {
     readSatelliteAssemblies?: () => System_Array<System_Object>,
     getLazyAssemblies?: any
     dotNetCriticalError?: any
-    getSatelliteAssemblies?: any
+    getSatelliteAssemblies?: any,
+    applyHotReload?: (id: string, metadataDelta: string, ilDeta: string) => void
   }
 }
 

src/Components/WebAssembly/WebAssembly/src/Infrastructure/JSInteropMethods.cs

@@ -1,8 +1,12 @@
 // 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.ComponentModel;
+using System.Linq;
+using System.Reflection;
 using System.Threading.Tasks;
+using Microsoft.AspNetCore.Components.HotReload;
 using Microsoft.AspNetCore.Components.RenderTree;
 using Microsoft.AspNetCore.Components.Web;
 using Microsoft.AspNetCore.Components.WebAssembly.Rendering;
@@ -40,5 +44,23 @@ public static Task DispatchEvent(WebEventDescriptor eventDescriptor, string even
                 webEvent.EventFieldInfo,
                 webEvent.EventArgs);
         }
+
+        /// <summary>
+        /// For framework use only.
+        /// </summary>
+        [JSInvokable(nameof(ApplyHotReloadDelta))]
+        public static void ApplyHotReloadDelta(string moduleId, byte[] metadataDelta, byte[] ilDeta)
+        {
+            var moduleIdGuid = Guid.Parse(moduleId);
+            var assembly = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(a => a.Modules.FirstOrDefault() is Module m && m.ModuleVersionId == moduleIdGuid);
+
+            if (assembly is not null)
+            {
+                System.Reflection.Metadata.AssemblyExtensions.ApplyUpdate(assembly, metadataDelta, ilDeta, ReadOnlySpan<byte>.Empty);
+            }
+
+            // Remove this once there's a runtime API to subscribe to.
+            typeof(ComponentBase).Assembly.GetType("Microsoft.AspNetCore.Components.HotReload.HotReloadManager")!.GetMethod("DeltaApplied", BindingFlags.NonPublic | BindingFlags.Static)!.Invoke(null, null);
+        }
     }
 }