[release/8.0] [Blazor] Improvements to SSR component activation

src/Components/Endpoints/src/DependencyInjection/ServerComponentSerializer.cs

@@ -18,21 +18,23 @@ public ServerComponentSerializer(IDataProtectionProvider dataProtectionProvider)
 
     public void SerializeInvocation(ref ComponentMarker marker, ServerComponentInvocationSequence invocationId, Type type, ParameterView parameters)
     {
-        var (sequence, serverComponent) = CreateSerializedServerComponent(invocationId, type, parameters);
+        var (sequence, serverComponent) = CreateSerializedServerComponent(invocationId, type, parameters, marker.Key);
         marker.WriteServerData(sequence, serverComponent);
     }
 
     private (int sequence, string payload) CreateSerializedServerComponent(
         ServerComponentInvocationSequence invocationId,
         Type rootComponent,
-        ParameterView parameters)
+        ParameterView parameters,
+        ComponentMarkerKey? key)
     {
         var sequence = invocationId.Next();
 
         var (definitions, values) = ComponentParameter.FromParameterView(parameters);
 
         var serverComponent = new ServerComponent(
             sequence,
+            key,
             rootComponent.Assembly.GetName().Name ?? throw new InvalidOperationException("Cannot prerender components from assemblies with a null name"),
             rootComponent.FullName ?? throw new InvalidOperationException("Cannot prerender component types with a null name"),
             definitions,

src/Components/Endpoints/src/Rendering/SSRRenderModeBoundary.cs

@@ -29,7 +29,7 @@ internal class SSRRenderModeBoundary : IComponent
     private readonly bool _prerender;
     private RenderHandle _renderHandle;
     private IReadOnlyDictionary<string, object?>? _latestParameters;
-    private string? _markerKey;
+    private ComponentMarkerKey? _markerKey;
 
     public IComponentRenderMode RenderMode { get; }
 
@@ -154,11 +154,11 @@ private void Prerender(RenderTreeBuilder builder)
         builder.CloseComponent();
     }
 
-    public ComponentMarker ToMarker(HttpContext httpContext, int sequence, object? key)
+    public ComponentMarker ToMarker(HttpContext httpContext, int sequence, object? componentKey)
     {
         // We expect that the '@key' and sequence number shouldn't change for a given component instance,
         // so we lazily compute the marker key once.
-        _markerKey ??= GenerateMarkerKey(sequence, key);
+        _markerKey ??= GenerateMarkerKey(sequence, componentKey);
 
         var parameters = _latestParameters is null
             ? ParameterView.Empty
@@ -190,10 +190,19 @@ public ComponentMarker ToMarker(HttpContext httpContext, int sequence, object? k
         return marker;
     }
 
-    private string GenerateMarkerKey(int sequence, object? key)
+    private ComponentMarkerKey GenerateMarkerKey(int sequence, object? componentKey)
     {
         var componentTypeNameHash = _componentTypeNameHashCache.GetOrAdd(_componentType, ComputeComponentTypeNameHash);
-        return $"{componentTypeNameHash}:{sequence}:{(key as IFormattable)?.ToString(null, CultureInfo.InvariantCulture)}";
+        var sequenceString = sequence.ToString(CultureInfo.InvariantCulture);
+
+        var locationHash = $"{componentTypeNameHash}:{sequenceString}";
+        var formattedComponentKey = (componentKey as IFormattable)?.ToString(null, CultureInfo.InvariantCulture) ?? string.Empty;
+
+        return new()
+        {
+            LocationHash = locationHash,
+            FormattedComponentKey = formattedComponentKey,
+        };
     }
 
     private static string ComputeComponentTypeNameHash(Type componentType)

src/Components/Endpoints/test/Microsoft.AspNetCore.Components.Endpoints.Tests.csproj

@@ -7,6 +7,7 @@
 
   <ItemGroup>
     <Compile Include="..\..\Shared\test\AutoRenderComponent.cs" Link="TestComponents\AutoRenderComponent.cs" />
+    <Compile Include="$(ComponentsSharedSourceRoot)src\WebRootComponentParameters.cs" Link="Shared\WebRootComponentParameters.cs" />
   </ItemGroup>
 
   <ItemGroup>

src/Components/Endpoints/test/WebRootComponentParametersTest.cs

@@ -0,0 +1,154 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Text.Json;
+
+namespace Microsoft.AspNetCore.Components.Endpoints;
+
+public class WebRootComponentParametersTest
+{
+    [Fact]
+    public void WebRootComponentParameters_DefinitelyEquals_ReturnsFalse_ForMismatchedParameterCount()
+    {
+        // Arrange
+        var parameters1 = CreateParameters(new() { ["First"] = 123 });
+        var parameters2 = CreateParameters(new() { ["First"] = 123, ["Second"] = "abc" });
+
+        // Act
+        var result = parameters1.DefinitelyEquals(parameters2);
+
+        // Assert
+        Assert.False(result);
+    }
+
+    [Fact]
+    public void WebRootComponentParameters_DefinitelyEquals_ReturnsFalse_ForMismatchedParameterNames()
+    {
+        // Arrange
+        var parameters1 = CreateParameters(new() { ["First"] = 123 });
+        var parameters2 = CreateParameters(new() { ["Second"] = 123 });
+
+        // Act
+        var result = parameters1.DefinitelyEquals(parameters2);
+
+        // Assert
+        Assert.False(result);
+    }
+
+    [Fact]
+    public void WebRootComponentParameters_DefinitelyEquals_ReturnsFalse_ForMismatchedParameterValues()
+    {
+        // Arrange
+        var parameters1 = CreateParameters(new() { ["First"] = 123 });
+        var parameters2 = CreateParameters(new() { ["First"] = 456 });
+
+        // Act
+        var result = parameters1.DefinitelyEquals(parameters2);
+
+        // Assert
+        Assert.False(result);
+    }
+
+    [Fact]
+    public void WebRootComponentParameters_DefinitelyEquals_ReturnsFalse_ForMismatchedParameterTypes()
+    {
+        // Arrange
+        var parameters1 = CreateParameters(new() { ["First"] = 123 });
+        var parameters2 = CreateParameters(new() { ["First"] = 123L });
+
+        // Act
+        var result = parameters1.DefinitelyEquals(parameters2);
+
+        // Assert
+        Assert.False(result);
+    }
+
+    public static readonly object[][] DefinitelyEqualParameterValues =
+    [
+        [123],
+        ["abc"],
+        [new { First = 123, Second = "abc" }],
+    ];
+
+    [Theory]
+    [MemberData(nameof(DefinitelyEqualParameterValues))]
+    public void WebRootComponentParameters_DefinitelyEquals_ReturnsTrue_ForSameParameterValues(object value)
+    {
+        // Arrange
+        var parameters1 = CreateParameters(new() { ["First"] = value });
+        var parameters2 = CreateParameters(new() { ["First"] = value });
+
+        // Act
+        var result = parameters1.DefinitelyEquals(parameters2);
+
+        // Assert
+        Assert.True(result);
+    }
+
+    [Fact]
+    public void WebRootComponentParameters_DefinitelyEquals_ReturnsTrue_ForEmptySetOfParameters()
+    {
+        // Arrange
+        var parameters1 = CreateParameters(new());
+        var parameters2 = CreateParameters(new());
+
+        // Act
+        var result = parameters1.DefinitelyEquals(parameters2);
+
+        // Assert
+        Assert.True(result);
+    }
+
+    [Fact]
+    public void WebRootComponentParameters_DefinitelyEquals_Throws_WhenComparingNonJsonElementParameterToJsonElement()
+    {
+        // Arrange
+        var parameters1 = CreateParametersWithNonJsonElements(new() { ["First"] = 123 });
+        var parameters2 = CreateParameters(new() { ["First"] = 456 });
+
+        // Act/assert
+        Assert.Throws<InvalidCastException>(() => parameters1.DefinitelyEquals(parameters2));
+    }
+
+    [Fact]
+    public void WebRootComponentParameters_DefinitelyEquals_Throws_WhenComparingJsonElementParameterToNonJsonElement()
+    {
+        // Arrange
+        var parameters1 = CreateParameters(new() { ["First"] = 123 });
+        var parameters2 = CreateParametersWithNonJsonElements(new() { ["First"] = 456 });
+
+        // Act/assert
+        Assert.Throws<InvalidCastException>(() => parameters1.DefinitelyEquals(parameters2));
+    }
+
+    [Fact]
+    public void WebRootComponentParameters_DefinitelyEquals_Throws_WhenComparingNonJsonElementParameters()
+    {
+        // Arrange
+        var parameters1 = CreateParametersWithNonJsonElements(new() { ["First"] = 123 });
+        var parameters2 = CreateParametersWithNonJsonElements(new() { ["First"] = 456 });
+
+        // Act/assert
+        Assert.Throws<InvalidCastException>(() => parameters1.DefinitelyEquals(parameters2));
+    }
+
+    private static WebRootComponentParameters CreateParameters(Dictionary<string, object> parameters)
+    {
+        var parameterView = ParameterView.FromDictionary(parameters);
+        var (parameterDefinitions, parameterValues) = ComponentParameter.FromParameterView(parameterView);
+        for (var i = 0; i < parameterValues.Count; i++)
+        {
+            // WebRootComponentParameters expects parameter values to be JsonElements.
+            var jsonElement = JsonSerializer.SerializeToElement(parameterValues[i]);
+            parameterValues[i] = jsonElement;
+        }
+        return new(parameterView, parameterDefinitions.AsReadOnly(), parameterValues.AsReadOnly());
+    }
+
+    private static WebRootComponentParameters CreateParametersWithNonJsonElements(Dictionary<string, object> parameters)
+    {
+        var parameterView = ParameterView.FromDictionary(parameters);
+        var (parameterDefinitions, parameterValues) = ComponentParameter.FromParameterView(parameterView);
+        return new(parameterView, parameterDefinitions.AsReadOnly(), parameterValues.AsReadOnly());
+    }
+}

src/Components/Server/src/Circuits/CircuitHost.cs

@@ -726,7 +726,7 @@ private async Task TryNotifyClientErrorAsync(IClientProxy client, string error,
     }
 
     internal Task UpdateRootComponents(
-        (RootComponentOperation, ComponentDescriptor?)[] operations,
+        CircuitRootComponentOperation[] operations,
         ProtectedPrerenderComponentApplicationStore store,
         IServerComponentDeserializer serverComponentDeserializer,
         CancellationToken cancellation)
@@ -735,6 +735,7 @@ internal Task UpdateRootComponents(
 
         return Renderer.Dispatcher.InvokeAsync(async () =>
         {
+            var webRootComponentManager = Renderer.GetOrCreateWebRootComponentManager();
             var shouldClearStore = false;
             Task[]? pendingTasks = null;
             try
@@ -766,7 +767,7 @@ internal Task UpdateRootComponents(
                     for (var i = 0; i < operations.Length; i++)
                     {
                         var operation = operations[i];
-                        if (operation.Item1.Type != RootComponentOperationType.Add)
+                        if (operation.Type != RootComponentOperationType.Add)
                         {
                             throw new InvalidOperationException($"The first set of update operations must always be of type {nameof(RootComponentOperationType.Add)}");
                         }
@@ -775,32 +776,32 @@ internal Task UpdateRootComponents(
                     pendingTasks = new Task[operations.Length];
                 }
 
-                for (var i = 0; i < operations.Length;i++)
+                for (var i = 0; i < operations.Length; i++)
                 {
-                    var (operation, descriptor) = operations[i];
+                    var operation = operations[i];
                     switch (operation.Type)
                     {
                         case RootComponentOperationType.Add:
-                            var task = Renderer.AddComponentAsync(descriptor.ComponentType, descriptor.Parameters, operation.SelectorId.Value.ToString(CultureInfo.InvariantCulture));
+                            var task = webRootComponentManager.AddRootComponentAsync(
+                                operation.SsrComponentId,
+                                operation.Descriptor.ComponentType,
+                                operation.Descriptor.Key,
+                                operation.Descriptor.Parameters);
                             if (pendingTasks != null)
                             {
                                 pendingTasks[i] = task;
                             }
                             break;
                         case RootComponentOperationType.Update:
-                            var componentType = Renderer.GetExistingComponentType(operation.ComponentId.Value);
-                            if (descriptor.ComponentType != componentType)
-                            {
-                                Log.InvalidComponentTypeForUpdate(_logger, message: "Component type mismatch.");
-                                throw new InvalidOperationException($"Incorrect type for descriptor '{descriptor.ComponentType.FullName}'");
-                            }
-
                             // We don't need to await component updates as any unhandled exception will be reported and terminate the circuit.
-                            _ = Renderer.UpdateRootComponentAsync(operation.ComponentId.Value, descriptor.Parameters);
-
+                            _ = webRootComponentManager.UpdateRootComponentAsync(
+                                operation.SsrComponentId,
+                                operation.Descriptor.ComponentType,
+                                operation.Descriptor.Key,
+                                operation.Descriptor.Parameters);
                             break;
                         case RootComponentOperationType.Remove:
-                            Renderer.RemoveExistingRootComponent(operation.ComponentId.Value);
+                            webRootComponentManager.RemoveRootComponent(operation.SsrComponentId);
                             break;
                     }
                 }

src/Components/Server/src/Circuits/CircuitRootComponentOperation.cs

@@ -0,0 +1,13 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.AspNetCore.Components.Server;
+
+internal sealed class CircuitRootComponentOperation(RootComponentOperation operation, WebRootComponentDescriptor? descriptor = null)
+{
+    public RootComponentOperationType Type => operation.Type;
+
+    public int SsrComponentId => operation.SsrComponentId;
+
+    public WebRootComponentDescriptor? Descriptor => descriptor;
+}

src/Components/Server/src/Circuits/IServerComponentDeserializer.cs

@@ -10,6 +10,5 @@ internal interface IServerComponentDeserializer
     bool TryDeserializeComponentDescriptorCollection(
         string serializedComponentRecords,
         out List<ComponentDescriptor> descriptors);
-    bool TryDeserializeSingleComponentDescriptor(ComponentMarker record, [NotNullWhen(true)] out ComponentDescriptor? result);
-    bool TryDeserializeRootComponentOperations(string serializedComponentOperations, out (RootComponentOperation, ComponentDescriptor?)[] operationsWithDescriptors);
+    bool TryDeserializeRootComponentOperations(string serializedComponentOperations, [NotNullWhen(true)] out CircuitRootComponentOperation[]? operationsWithDescriptors);
 }

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

@@ -70,12 +70,6 @@ protected override void AttachRootComponentToBrowser(int componentId, string dom
         _ = CaptureAsyncExceptions(attachComponentTask);
     }
 
-    internal Task UpdateRootComponentAsync(int componentId, ParameterView initialParameters) =>
-        RenderRootComponentAsync(componentId, initialParameters);
-
-    internal void RemoveExistingRootComponent(int componentId) =>
-        RemoveRootComponent(componentId);
-
     internal Type GetExistingComponentType(int componentId) =>
         GetComponentState(componentId).Component.GetType();