Improvements and cleanup

Author: MackinnonBuck

src/Components/Endpoints/src/DependencyInjection/AutoComponentMarker.cs

@@ -9,19 +9,17 @@ namespace Microsoft.AspNetCore.Components.Endpoints;
 // See the details of the component serialization protocol in ServerComponentDeserializer.cs on the Components solution.
 internal sealed class ServerComponentSerializer
 {
-    public const int PreambleBufferSize = 3;
-
     private readonly ITimeLimitedDataProtector _dataProtector;
 
     public ServerComponentSerializer(IDataProtectionProvider dataProtectionProvider) =>
         _dataProtector = dataProtectionProvider
             .CreateProtector(ServerComponentSerializationSettings.DataProtectionProviderPurpose)
             .ToTimeLimitedDataProtector();
 
-    public ServerComponentMarker SerializeInvocation(ServerComponentInvocationSequence invocationId, Type type, ParameterView parameters, string key, bool prerendered)
+    public void SerializeInvocation(ref ComponentMarker marker, ServerComponentInvocationSequence invocationId, Type type, ParameterView parameters)
     {
         var (sequence, serverComponent) = CreateSerializedServerComponent(invocationId, type, parameters);
-        return prerendered ? ServerComponentMarker.Prerendered(sequence, serverComponent, key) : ServerComponentMarker.NonPrerendered(sequence, serverComponent, key);
+        marker.WriteServerData(sequence, serverComponent);
     }
 
     private (int sequence, string payload) CreateSerializedServerComponent(
@@ -45,29 +43,4 @@ public ServerComponentMarker SerializeInvocation(ServerComponentInvocationSequen
         var protectedBytes = _dataProtector.Protect(serializedServerComponentBytes, ServerComponentSerializationSettings.DataExpiration);
         return (serverComponent.Sequence, Convert.ToBase64String(protectedBytes));
     }
-
-    /// <remarks>
-    /// Remember to update <see cref="PreambleBufferSize"/> if the number of entries being appended in this function changes.
-    /// </remarks>
-    internal static void AppendPreamble(TextWriter writer, ServerComponentMarker record)
-    {
-        var serializedStartRecord = JsonSerializer.Serialize(
-            record,
-            ServerComponentSerializationSettings.JsonSerializationOptions);
-
-        writer.Write("<!--Blazor:");
-        writer.Write(serializedStartRecord);
-        writer.Write("-->");
-    }
-
-    internal static void AppendEpilogue(TextWriter writer, ServerComponentMarker record)
-    {
-        var endRecord = JsonSerializer.Serialize(
-            record.GetEndRecord(),
-            ServerComponentSerializationSettings.JsonSerializationOptions);
-
-        writer.Write("<!--Blazor:");
-        writer.Write(endRecord);
-        writer.Write("-->");
-    }
 }

src/Components/Endpoints/src/DependencyInjection/AutoComponentSerializer.cs

@@ -8,7 +8,7 @@ namespace Microsoft.AspNetCore.Components.Endpoints;
 // See the details of the component serialization protocol in WebAssemblyComponentDeserializer.cs on the Components solution.
 internal sealed class WebAssemblyComponentSerializer
 {
-    public static WebAssemblyComponentMarker SerializeInvocation(Type type, ParameterView parameters, string? key, bool prerendered)
+    public static void SerializeInvocation(ref ComponentMarker marker, Type type, ParameterView parameters)
     {
         var assembly = type.Assembly.GetName().Name ?? throw new InvalidOperationException("Cannot prerender components from assemblies with a null name");
         var typeFullName = type.FullName ?? throw new InvalidOperationException("Cannot prerender component types with a null name");
@@ -19,29 +19,6 @@ public static WebAssemblyComponentMarker SerializeInvocation(Type type, Paramete
         var serializedDefinitions = Convert.ToBase64String(JsonSerializer.SerializeToUtf8Bytes(definitions, WebAssemblyComponentSerializationSettings.JsonSerializationOptions));
         var serializedValues = Convert.ToBase64String(JsonSerializer.SerializeToUtf8Bytes(values, WebAssemblyComponentSerializationSettings.JsonSerializationOptions));
 
-        return prerendered ? WebAssemblyComponentMarker.Prerendered(assembly, typeFullName, serializedDefinitions, serializedValues, key) :
-            WebAssemblyComponentMarker.NonPrerendered(assembly, typeFullName, serializedDefinitions, serializedValues, key);
-    }
-
-    internal static void AppendPreamble(TextWriter writer, WebAssemblyComponentMarker record)
-    {
-        var serializedStartRecord = JsonSerializer.Serialize(
-            record,
-            WebAssemblyComponentSerializationSettings.JsonSerializationOptions);
-
-        writer.Write("<!--Blazor:");
-        writer.Write(serializedStartRecord);
-        writer.Write("-->");
-    }
-
-    internal static void AppendEpilogue(TextWriter writer, WebAssemblyComponentMarker record)
-    {
-        var endRecord = JsonSerializer.Serialize(
-            record.GetEndRecord(),
-            WebAssemblyComponentSerializationSettings.JsonSerializationOptions);
-
-        writer.Write("<!--Blazor:");
-        writer.Write(endRecord);
-        writer.Write("-->");
+        marker.WriteWebAssemblyData(assembly, typeFullName, serializedDefinitions, serializedValues);
     }
 }

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

@@ -25,10 +25,9 @@
   </ItemGroup>
 
   <ItemGroup>
+    <Compile Include="$(SharedSourceRoot)Components\ComponentMarker.cs" LinkBase="DependencyInjection" />
     <Compile Include="$(SharedSourceRoot)Components\WebAssemblyComponentSerializationSettings.cs" LinkBase="DependencyInjection" />
     <Compile Include="$(SharedSourceRoot)Components\ServerComponentSerializationSettings.cs" LinkBase="DependencyInjection" />
-    <Compile Include="$(SharedSourceRoot)Components\WebAssemblyComponentMarker.cs" LinkBase="DependencyInjection" />
-    <Compile Include="$(SharedSourceRoot)Components\ServerComponentMarker.cs" LinkBase="DependencyInjection" />
     <Compile Include="$(SharedSourceRoot)Components\ServerComponent.cs" LinkBase="DependencyInjection" />
     <Compile Include="$(RepoRoot)src\Shared\Components\ComponentParameter.cs" LinkBase="DependencyInjection" />
     <Compile Include="$(RepoRoot)src\Shared\Components\PrerenderComponentApplicationStore.cs" LinkBase="DependencyInjection" />

src/Components/Endpoints/src/DependencyInjection/WebAssemblyComponentSerializer.cs

@@ -3,6 +3,7 @@
 
 using System.Runtime.InteropServices;
 using System.Text.Encodings.Web;
+using System.Text.Json;
 using Microsoft.AspNetCore.Components.RenderTree;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Http;
@@ -199,35 +200,22 @@ private void WriteComponentHtml(int componentId, TextWriter output, bool allowBo
         var componentState = (EndpointComponentState)GetComponentState(componentId);
         var renderBoundaryMarkers = allowBoundaryMarkers && componentState.StreamRendering;
 
-        // TODO: It's not clear that we actually want to emit the interactive component markers using this
-        // HTML-comment syntax that we've used historically, plus we likely want some way to coalesce both
-        // marker types into a single thing for auto mode (the code below emits both separately for auto).
-        // It may be better to use a custom element like <blazor-component ...>[prerendered]<blazor-component>
-        // so it's easier for the JS code to react automatically whenever this gets inserted or updated during
-        // streaming SSR or progressively-enhanced navigation.
-        var (serverMarker, webAssemblyMarker) = componentState.Component is SSRRenderModeBoundary boundary
-            ? boundary.ToMarkers(_httpContext, sequenceAndKey.Sequence, sequenceAndKey.Key)
-            : default;
-
-        if (serverMarker.HasValue)
+        ComponentEndMarker? endMarkerOrNull = default;
+
+        if (componentState.Component is SSRRenderModeBoundary boundary)
         {
-            if (!_httpContext.Response.HasStarted)
+            var marker = boundary.ToMarker(_httpContext, sequenceAndKey.Sequence, sequenceAndKey.Key);
+            endMarkerOrNull = marker.ToEndMarker();
+
+            if (!_httpContext.Response.HasStarted && marker.Type is ComponentMarker.ServerMarkerType or ComponentMarker.WebAssemblyMarkerType)
             {
                 _httpContext.Response.Headers.CacheControl = "no-cache, no-store, max-age=0";
             }
 
-            if (webAssemblyMarker.HasValue)
-            {
-                AutoComponentSerializer.AppendPreamble(output, serverMarker.Value, webAssemblyMarker.Value);
-            }
-            else
-            {
-                ServerComponentSerializer.AppendPreamble(output, serverMarker.Value);
-            }
-        }
-        else if (webAssemblyMarker.HasValue)
-        {
-            WebAssemblyComponentSerializer.AppendPreamble(output, webAssemblyMarker.Value);
+            var serializedStartRecord = JsonSerializer.Serialize(marker, ServerComponentSerializationSettings.JsonSerializationOptions);
+            output.Write("<!--Blazor:");
+            output.Write(serializedStartRecord);
+            output.Write("-->");
         }
 
         if (renderBoundaryMarkers)
@@ -246,26 +234,12 @@ private void WriteComponentHtml(int componentId, TextWriter output, bool allowBo
             output.Write("-->");
         }
 
-        if (serverMarker.HasValue)
+        if (endMarkerOrNull is { } endMarker)
         {
-            if (serverMarker.Value.PrerenderId is not null)
-            {
-                if (webAssemblyMarker.HasValue)
-                {
-                    AutoComponentSerializer.AppendEpilogue(output, serverMarker.Value);
-                }
-                else
-                {
-                    ServerComponentSerializer.AppendEpilogue(output, serverMarker.Value);
-                }
-            }
-        }
-        else if (webAssemblyMarker.HasValue)
-        {
-            if (webAssemblyMarker.Value.PrerenderId is not null)
-            {
-                WebAssemblyComponentSerializer.AppendEpilogue(output, webAssemblyMarker.Value);
-            }
+            var serializedEndRecord = JsonSerializer.Serialize(endMarker, ServerComponentSerializationSettings.JsonSerializationOptions);
+            output.Write("<!--Blazor:");
+            output.Write(serializedEndRecord);
+            output.Write("-->");
         }
     }
 

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

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics;
 using System.Globalization;
 using System.Security.Cryptography;
 using System.Text;
@@ -98,7 +99,7 @@ private void Prerender(RenderTreeBuilder builder)
         builder.CloseComponent();
     }
 
-    public (ServerComponentMarker?, WebAssemblyComponentMarker?) ToMarkers(HttpContext httpContext, int sequence, object? key)
+    public ComponentMarker ToMarker(HttpContext httpContext, int sequence, object? key)
     {
         // We expect that the '@key' and sequence number shouldn't change for a given component instance,
         // so we lazily compute the marker key once.
@@ -108,24 +109,30 @@ private void Prerender(RenderTreeBuilder builder)
             ? ParameterView.Empty
             : ParameterView.FromDictionary((IDictionary<string, object?>)_latestParameters);
 
-        ServerComponentMarker? serverMarker = null;
+        var marker = _renderMode switch
+        {
+            ServerRenderMode server => ComponentMarker.Create(ComponentMarker.ServerMarkerType, server.Prerender, _markerKey),
+            WebAssemblyRenderMode webAssembly => ComponentMarker.Create(ComponentMarker.WebAssemblyMarkerType, webAssembly.Prerender, _markerKey),
+            AutoRenderMode auto => ComponentMarker.Create(ComponentMarker.AutoMarkerType, auto.Prerender, _markerKey),
+            _ => throw new UnreachableException($"Unknown render mode {_renderMode.GetType().FullName}"),
+        };
+
         if (_renderMode is ServerRenderMode or AutoRenderMode)
         {
             // Lazy because we don't actually want to require a whole chain of services including Data Protection
             // to be required unless you actually use Server render mode.
             var serverComponentSerializer = httpContext.RequestServices.GetRequiredService<ServerComponentSerializer>();
 
             var invocationId = EndpointHtmlRenderer.GetOrCreateInvocationId(httpContext);
-            serverMarker = serverComponentSerializer.SerializeInvocation(invocationId, _componentType, parameters, _markerKey, _prerender);
+            serverComponentSerializer.SerializeInvocation(ref marker, invocationId, _componentType, parameters);
         }
 
-        WebAssemblyComponentMarker? webAssemblyMarker = null;
         if (_renderMode is WebAssemblyRenderMode or AutoRenderMode)
         {
-            webAssemblyMarker = WebAssemblyComponentSerializer.SerializeInvocation(_componentType, parameters, _markerKey, _prerender);
+            WebAssemblyComponentSerializer.SerializeInvocation(ref marker, _componentType, parameters);
         }
 
-        return (serverMarker, webAssemblyMarker);
+        return marker;
     }
 
     private string GenerateMarkerKey(int sequence, object? key)