Support layouts and anonymously-typed parameter objects

Author: SteveSandersonMS

src/Mvc/Mvc.ViewFeatures/src/PublicAPI.Unshipped.txt

@@ -5,8 +5,8 @@ Microsoft.AspNetCore.Mvc.Diagnostics.BeforeRazorComponentEventData
 Microsoft.AspNetCore.Mvc.Diagnostics.BeforeRazorComponentEventData.RenderMode.get -> Microsoft.AspNetCore.Mvc.Rendering.RenderMode
 Microsoft.AspNetCore.Mvc.Rendering.FormMethod.Dialog = 2 -> Microsoft.AspNetCore.Mvc.Rendering.FormMethod
 Microsoft.AspNetCore.Mvc.ViewFeatures.RazorComponentResult
-Microsoft.AspNetCore.Mvc.ViewFeatures.RazorComponentResult.Parameters.get -> Microsoft.AspNetCore.Components.ParameterView
-Microsoft.AspNetCore.Mvc.ViewFeatures.RazorComponentResult.Parameters.set -> void
+~Microsoft.AspNetCore.Mvc.ViewFeatures.RazorComponentResult.Parameters.get -> object
+~Microsoft.AspNetCore.Mvc.ViewFeatures.RazorComponentResult.Parameters.set -> void
 Microsoft.AspNetCore.Mvc.ViewFeatures.RazorComponentResult.RenderMode.get -> Microsoft.AspNetCore.Mvc.Rendering.RenderMode
 Microsoft.AspNetCore.Mvc.ViewFeatures.RazorComponentResult.RenderMode.set -> void
 Microsoft.AspNetCore.Mvc.ViewFeatures.RazorComponentResult.StatusCode.get -> int?

src/Mvc/Mvc.ViewFeatures/src/RazorComponents/RazorComponentResult.cs

@@ -43,7 +43,7 @@ public RazorComponentResult(Type componentType)
     /// <summary>
     /// Gets or sets the parameters for the component.
     /// </summary>
-    public ParameterView Parameters { get; set; } = ParameterView.Empty;
+    public object Parameters { get; set; }
 
     /// <summary>
     /// Gets or sets the rendering mode.

src/Mvc/Mvc.ViewFeatures/src/RazorComponents/RazorComponentResultExecutor.cs

@@ -3,6 +3,7 @@
 
 using System.Diagnostics;
 using System.Text;
+using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Internal;
 using Microsoft.AspNetCore.Mvc.Formatters;
 using Microsoft.AspNetCore.Mvc.Infrastructure;
@@ -70,25 +71,34 @@ public virtual async Task ExecuteAsync(ActionContext actionContext, RazorCompone
         }
 
         await using var writer = WriterFactory.CreateWriter(response.Body, resolvedContentTypeEncoding);
+        DiagnosticListener.BeforeRazorComponent(result.ComponentType, result.RenderMode, actionContext);
+        await RenderComponentToResponse(actionContext, result, writer);
+        DiagnosticListener.AfterRazorComponent(result.ComponentType, result.RenderMode, actionContext);
 
-        var componentPrerenderer = actionContext.HttpContext.RequestServices.GetRequiredService<ComponentPrerenderer>();
+        // Perf: Invoke FlushAsync to ensure any buffered content is asynchronously written to the underlying
+        // response asynchronously. In the absence of this line, the buffer gets synchronously written to the
+        // response as part of the Dispose which has a perf impact.
+        await writer.FlushAsync();
+    }
 
-        DiagnosticListener.BeforeRazorComponent(result.ComponentType, result.RenderMode, actionContext);
-        await componentPrerenderer.Dispatcher.InvokeAsync(async () =>
+    private static Task RenderComponentToResponse(ActionContext actionContext, RazorComponentResult result, TextWriter writer)
+    {
+        var componentPrerenderer = actionContext.HttpContext.RequestServices.GetRequiredService<ComponentPrerenderer>();
+        return componentPrerenderer.Dispatcher.InvokeAsync(async () =>
         {
+            // We could pool these dictionary instances if we wanted. We could even skip the dictionary
+            // phase entirely if we added some new ParameterView.FromSingleValue(name, value) API.
+            var hostParameters = ParameterView.FromDictionary(new Dictionary<string, object>
+            {
+                { nameof(RazorComponentResultHost.RazorComponentResult), result },
+            });
+
             var htmlContent = await componentPrerenderer.PrerenderComponentAsync(
                 actionContext,
-                result.ComponentType,
+                typeof(RazorComponentResultHost),
                 result.RenderMode,
-                result.Parameters);
+                hostParameters);
             await htmlContent.WriteToAsync(writer);
         });
-
-        DiagnosticListener.AfterRazorComponent(result.ComponentType, result.RenderMode, actionContext);
-
-        // Perf: Invoke FlushAsync to ensure any buffered content is asynchronously written to the underlying
-        // response asynchronously. In the absence of this line, the buffer gets synchronously written to the
-        // response as part of the Dispose which has a perf impact.
-        await writer.FlushAsync();
     }
 }

src/Mvc/Mvc.ViewFeatures/src/RazorComponents/RazorComponentResultHost.cs

@@ -0,0 +1,77 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Reflection;
+using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components.Rendering;
+using Microsoft.Extensions.Internal;
+
+namespace Microsoft.AspNetCore.Mvc.ViewFeatures;
+
+/// <summary>
+/// Internal component type that acts as a root component when executing a RazorComponentResult. It takes
+/// care of rendering the component inside its hierarchy of layouts (via LayoutView) as well as converting
+/// any information we want from RazorComponentResult into component parameters. We could also use this to
+/// supply other data from the original HttpContext as component parameters, e.g., for model binding.
+///
+/// It happens to be almost the same as RouteView except it doesn't supply any query parameters. We can
+/// resolve that at the same time we implement support for form posts.
+/// </summary>
+internal class RazorComponentResultHost : IComponent
+{
+    private RenderHandle _renderHandle;
+
+    public RazorComponentResult RazorComponentResult { get; private set; }
+
+    public void Attach(RenderHandle renderHandle)
+        => _renderHandle = renderHandle;
+
+    public Task SetParametersAsync(ParameterView parameters)
+    {
+        foreach (var kvp in parameters)
+        {
+            switch (kvp.Name)
+            {
+                case nameof(RazorComponentResult):
+                    RazorComponentResult = (RazorComponentResult)kvp.Value;
+                    break;
+                default:
+                    throw new ArgumentException($"Unknown parameter '{kvp.Name}'");
+            }
+        }
+
+        if (RazorComponentResult is null)
+        {
+            throw new InvalidOperationException($"Failed to supply nonnull value for required parameter '{nameof(RazorComponentResult)}'");
+        }
+
+        _renderHandle.Render(BuildRenderTree);
+        return Task.CompletedTask;
+    }
+
+    private void BuildRenderTree(RenderTreeBuilder builder)
+    {
+        var pageLayoutType = RazorComponentResult.ComponentType.GetCustomAttribute<LayoutAttribute>()?.LayoutType;
+
+        builder.OpenComponent<LayoutView>(0);
+        builder.AddComponentParameter(1, nameof(LayoutView.Layout), pageLayoutType);
+        builder.AddComponentParameter(2, nameof(LayoutView.ChildContent), (RenderFragment)RenderPageWithParameters);
+        builder.CloseComponent();
+    }
+
+    private void RenderPageWithParameters(RenderTreeBuilder builder)
+    {
+        builder.OpenComponent(0, RazorComponentResult.ComponentType);
+
+        if (RazorComponentResult.Parameters is not null)
+        {
+            var dict = PropertyHelper.ObjectToDictionary(RazorComponentResult.Parameters);
+            foreach (var kvp in dict)
+            {
+                builder.AddComponentParameter(1, kvp.Key, kvp.Value);
+            }
+        }
+
+        builder.CloseComponent();
+    }
+}