From e77120f5df75de29a40c14e2ad3891125519b1d9 Mon Sep 17 00:00:00 2001 From: Steve Sanderson Date: Wed, 28 Jun 2017 19:49:55 +0100 Subject: [PATCH] Implement optional server-side prerendering support --- .../ClientServerApp.Client/FetchData.cshtml | 2 +- .../Shared/NavMenu.cshtml | 2 +- .../ClientServerApp.Server/Startup.cs | 6 +- .../BlazorApplicationBuilderExtensions.cs | 46 +++- src/Blazor.Host/Host/Prerendering.cs | 215 ++++++++++++++++++ src/Blazor.Host/Host/RazorCompilation.cs | 21 +- .../wwwroot/_framework/Blazor.Runtime.js | 11 +- .../Components/BlazorContext.cs | 12 + src/Blazor.Runtime/Components/Component.cs | 44 +++- .../Components/RazorComponent.cs | 27 ++- src/Blazor.Runtime/Interop/Browser.cs | 3 + src/Blazor.Runtime/Interop/Components.cs | 17 +- src/Blazor.Runtime/Interop/Env.cs | 14 ++ src/Blazor.Runtime/Interop/ManagedGCHandle.cs | 16 +- src/Blazor.Runtime/Routing/Router.cs | 19 +- src/Blazor.Runtime/VirtualDom/VDomBuilder.cs | 16 +- src/Blazor.Runtime/VirtualDom/VDomItem.cs | 2 +- 17 files changed, 419 insertions(+), 54 deletions(-) create mode 100644 src/Blazor.Host/Host/Prerendering.cs create mode 100644 src/Blazor.Runtime/Components/BlazorContext.cs create mode 100644 src/Blazor.Runtime/Interop/Env.cs diff --git a/samples/ClientServerApp/ClientServerApp.Client/FetchData.cshtml b/samples/ClientServerApp/ClientServerApp.Client/FetchData.cshtml index c0e4da23..83374292 100644 --- a/samples/ClientServerApp/ClientServerApp.Client/FetchData.cshtml +++ b/samples/ClientServerApp/ClientServerApp.Client/FetchData.cshtml @@ -38,7 +38,7 @@ else { using (var client = new HttpClient()) { - var json = await client.GetStringAsync("/api/SampleData/WeatherForecasts"); + var json = await client.GetStringAsync(AbsoluteUrl("/api/SampleData/WeatherForecasts")); forecasts = JsonUtil.Deserialize(json); } } diff --git a/samples/ClientServerApp/ClientServerApp.Client/Shared/NavMenu.cshtml b/samples/ClientServerApp/ClientServerApp.Client/Shared/NavMenu.cshtml index ee151ff9..67bfbf15 100644 --- a/samples/ClientServerApp/ClientServerApp.Client/Shared/NavMenu.cshtml +++ b/samples/ClientServerApp/ClientServerApp.Client/Shared/NavMenu.cshtml @@ -14,7 +14,7 @@
  • - + Home
    • diff --git a/samples/ClientServerApp/ClientServerApp.Server/Startup.cs b/samples/ClientServerApp/ClientServerApp.Server/Startup.cs index b8363f87..da09804a 100644 --- a/samples/ClientServerApp/ClientServerApp.Server/Startup.cs +++ b/samples/ClientServerApp/ClientServerApp.Server/Startup.cs @@ -65,7 +65,11 @@ public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerF }); // All other requests handled by serving the SPA - app.UseBlazorUI(Path.Combine("..", "ClientServerApp.Client")); + app.UseBlazorUI(Path.Combine("..", "ClientServerApp.Client"), opts => + { + opts.EnableServerSidePrerendering = true; + opts.ClientAssemblyName = "ClientServerApp.Client.dll"; + }); } } } diff --git a/src/Blazor.Host/Host/BlazorApplicationBuilderExtensions.cs b/src/Blazor.Host/Host/BlazorApplicationBuilderExtensions.cs index bb25ab9f..d08008a6 100644 --- a/src/Blazor.Host/Host/BlazorApplicationBuilderExtensions.cs +++ b/src/Blazor.Host/Host/BlazorApplicationBuilderExtensions.cs @@ -6,18 +6,32 @@ using System; using System.Collections.Generic; using System.IO; +using System.Linq; using System.Reflection; +using System.Runtime.Loader; using System.Text; namespace Blazor.Host { + public class BlazorUIOptions + { + public bool EnableServerSidePrerendering { get; set; } + public string ClientAssemblyName { get; set; } + } + public static class BlazorApplicationBuilderExtensions { private readonly static Assembly _hostAssembly = typeof(BlazorApplicationBuilderExtensions).GetTypeInfo().Assembly; private readonly static string _embeddedResourceProjectName = "Blazor.Host"; // Note: Not the same as _hostAssembly.Name - public static IApplicationBuilder UseBlazorUI(this IApplicationBuilder app, string rootPath) + public static IApplicationBuilder UseBlazorUI(this IApplicationBuilder app, string rootPath, Action configure = null) { + var options = new BlazorUIOptions(); + if (configure != null) + { + configure(options); + } + var staticFilesRoot = Path.GetFullPath(Path.Combine(rootPath, "wwwroot")); var fileProvider = new PhysicalFileProvider(staticFilesRoot); @@ -26,12 +40,6 @@ public static IApplicationBuilder UseBlazorUI(this IApplicationBuilder app, stri contentTypeProvider.Mappings.Add(".exe", "application/octet-stream"); contentTypeProvider.Mappings.Add(".wasm", "application/octet-stream"); - app.UseDefaultFiles(new DefaultFilesOptions - { - FileProvider = fileProvider, - // RequestPath = requestPath, // TODO: Allow mounting in subdir of URL space - }); - app.UseStaticFiles(new StaticFileOptions { FileProvider = fileProvider, @@ -76,6 +84,15 @@ public static IApplicationBuilder UseBlazorUI(this IApplicationBuilder app, stri app.UseLiveReloading(); + if (options.EnableServerSidePrerendering) + { + if (string.IsNullOrEmpty(options.ClientAssemblyName)) + { + throw new ArgumentException($"If {nameof(options.EnableServerSidePrerendering)} is true, then you must specify a value for {nameof(options.ClientAssemblyName)}."); + } + Prerendering.EnablePrerendering(clientBinDir, options.ClientAssemblyName); + } + // SPA fallback routing - for requests that don't match physical files, and don't appear // to be attempts to fetch static files, map them all to /index.html app.Use(async (context, next) => @@ -83,9 +100,18 @@ public static IApplicationBuilder UseBlazorUI(this IApplicationBuilder app, stri var requestPath = context.Request.Path; if (!IsStaticFileRequest(requestPath.Value)) { - // TODO: There's probably a better way to return this file using the static files middleware - context.Response.ContentType = "text/html"; - await context.Response.SendFileAsync(Path.Combine(rootPath, "wwwroot", "index.html")); + if (options.EnableServerSidePrerendering) + { + var html = await Prerendering.PrerenderPage(rootPath, options.ClientAssemblyName, context); + context.Response.ContentType = "text/html"; + await context.Response.WriteAsync(html); + } + else + { + // TODO: There's probably a better way to return this file using the static files middleware + context.Response.ContentType = "text/html"; + await context.Response.SendFileAsync(Path.Combine(rootPath, "wwwroot", "index.html")); + } } else { diff --git a/src/Blazor.Host/Host/Prerendering.cs b/src/Blazor.Host/Host/Prerendering.cs new file mode 100644 index 00000000..810db5f3 --- /dev/null +++ b/src/Blazor.Host/Host/Prerendering.cs @@ -0,0 +1,215 @@ +using System.IO; +using System.Reflection; +using System.Text; +using System.Threading.Tasks; +using Blazor.Components; +using Blazor.Routing; +using Blazor.VirtualDom; +using MiniJSON; +using System.Collections.Generic; +using System; +using System.Runtime.Loader; +using System.Linq; +using Blazor.Sdk.Host; +using Blazor.Runtime.Components; +using Microsoft.AspNetCore.Http; +using System.Diagnostics; + +namespace Blazor.Host +{ + // The code here is incomplete and uses (uncached) reflection to access internals on Blazor.Runtime + // just as a shortcut to avoid refactoring properly. To clean this up, consider exposing + // the relevant APIs from Blazor.Runtime properly or even using InternalsVisibleTo. + + internal static class Prerendering + { + private static string[] viewReferenceAssemblies; + + internal static void EnablePrerendering(string clientBinDir, string assemblyName) + { + var clientAppAssemblyPath = Path.Combine(clientBinDir, assemblyName); + var entrypointAssembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(clientAppAssemblyPath); + var entrypoint = entrypointAssembly.EntryPoint; + entrypoint.Invoke(null, new[] { new string[0] }); + var envField = typeof(Blazor.Runtime.Env) + .GetField("_isServer", BindingFlags.Static | BindingFlags.NonPublic); + envField.SetValue(null, true); + viewReferenceAssemblies = Directory.EnumerateFiles(clientBinDir, "*.dll") + .Where(binDirEntry => !string.Equals(binDirEntry, assemblyName, StringComparison.OrdinalIgnoreCase)) + .ToArray(); + } + + private static async Task PrerenderUrl(string rootDir, HttpContext httpContext, IEnumerable viewAssemblies) + { + var mountPageFromUrlMethod = typeof(Router).GetMethod("MountPageFromUrl", BindingFlags.Static | BindingFlags.NonPublic); + + Router.ViewAssemblies = viewAssemblies; + var component = (Component)mountPageFromUrlMethod.Invoke(null, new object[] { + httpContext.Request.Path.Value, + new BlazorContext(GetAbsoluteUrl(httpContext.Request)) + }); + return await RenderComponentHtml(component); + } + + private static string GetAbsoluteUrl(HttpRequest request) + { + return string.Concat( + request.Scheme, + "://", + request.Host.ToUriComponent(), + request.PathBase.ToUriComponent(), + request.Path.ToUriComponent(), + request.QueryString.ToUriComponent()); + } + + private static async Task RenderComponentHtml(Component component) + { + var sb = new StringBuilder(); + await AppendComponentHtml(sb, component); + return sb.ToString(); + } + + private static async Task AppendComponentHtml(StringBuilder sb, Component component) + { + var builder = (VDomBuilder)typeof(Component).GetField("builder", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(component); + if (builder == null) + { + throw new NullReferenceException("BAD2"); + } + var vdomItems = (VDomItem[])typeof(VDomBuilder).GetProperty("Items", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(builder); + await AppendVDom(sb, component, vdomItems, 0); + } + + private static async Task AppendVDom(StringBuilder sb, Component ownerComponent, VDomItem[] vdom, int rootIndex) + { + var rootItem = vdom[rootIndex]; + switch (rootItem.ItemType) + { + case VDomItemType.Element: + sb.AppendFormat("<{0}", rootItem.ElementTagName); + var hasClosedTag = false; + for (var childIndex = rootIndex + 1; childIndex <= rootItem.DescendantsEndIndex; childIndex++) + { + // Need to close the tag when we see the first non-attribute child + var childItem = vdom[childIndex]; + if (!hasClosedTag) + { + + if (childItem.ItemType != VDomItemType.Attribute) + { + sb.Append(">"); + hasClosedTag = true; + } + } + + await AppendVDom(sb, ownerComponent, vdom, childIndex); + + // Skip descendants of children + if (childItem.ItemType == VDomItemType.Element) + { + childIndex = childItem.DescendantsEndIndex; + } + } + if (!hasClosedTag) + { + sb.Append(">"); + } + sb.AppendFormat("", rootItem.ElementTagName); + break; + case VDomItemType.Attribute: + var attributeValue = GetAttributeStringValue(rootItem); + if (rootItem.AttributeName.Equals("href", StringComparison.OrdinalIgnoreCase) && attributeValue.StartsWith("~/")) + { + // When rendering on server, convert virtual paths to regular URLs + attributeValue = attributeValue.Substring(1); + } + sb.AppendFormat(" {0}=\"{1}\"", + rootItem.AttributeName, + HtmlAttributeEncode(attributeValue)); + break; + case VDomItemType.TextNode: + sb.Append(HtmlTextEncode(rootItem.TextNodeContents)); + break; + case VDomItemType.Component: + var componentInstance = rootItem.ComponentInstance; + if (componentInstance == null) + { + var childComponent = Interop.Components.InstantiateAndMountComponent( + "ignored", // elementRef + ownerComponent, + rootIndex); + if (childComponent == null) + { + throw new InvalidOperationException("Could not find child component immediately after instantiation."); + } + await AppendComponentHtml(sb, childComponent); + } + else + { + componentInstance.MountAsComponent("ignoredElemRef"); + var firstRenderCompletedTask = (Task)typeof(Component).GetProperty("FirstRenderCompletedTask", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(componentInstance); + if (firstRenderCompletedTask != null) + { + await firstRenderCompletedTask; + } + await AppendComponentHtml(sb, componentInstance); + } + break; + } + } + + internal static async Task PrerenderPage(string clientRootDir, string clientAppAssemblyName, HttpContext httpContext) + { + // TODO: Obviously there's no need to be reading this on every request + var pageTemplate = File.ReadAllText(Path.Combine(clientRootDir, "wwwroot", "index.html")); + + // TODO: Don't reload view assembly on every request. Only do so when changed. + // It's crazily inefficient to keep loading new copies of the same assembly like this. + var viewsAssembly = GetCompiledViewsAssembly(clientRootDir, clientAppAssemblyName, viewReferenceAssemblies); + + return pageTemplate.Replace( + "
    Loading...
    ", + "
    " + await PrerenderUrl(clientRootDir, httpContext, new[] { viewsAssembly })) + "
    "; + } + + private static string GetAttributeStringValue(VDomItem attributeItem) + { + return attributeItem.AttributeStringValue + ?? attributeItem.AttributeObjectValue?.ToString() + ?? string.Empty; // No need to serialise references to delegates, etc, since we can't call them in prerendering anyway + } + + private static string HtmlTextEncode(string textNodeContents) + { + // TODO: Actually encode + return textNodeContents; + } + + private static string HtmlAttributeEncode(string attributeValue) + { + // TODO: Actually encode + return attributeValue; + } + + private static Component FindComponentById(int id) + { + return (Component)typeof(Component) + .GetMethod("FindById", BindingFlags.Static | BindingFlags.NonPublic) + .Invoke(null, new object[] { id }); + } + + private static int viewAssemblyCount = 0; + private static Assembly GetCompiledViewsAssembly(string rootPath, string appAssemblyName, string[] referenceAssemblies) + { + var viewsAssemblyName = appAssemblyName.Replace(".dll", $".{ ++viewAssemblyCount }.Views.dll"); + var viewAssemblyBytes = RazorCompilation.GetCompiledViewsAssembly( + rootPath, + viewsAssemblyName, + referenceAssemblies); + using (var ms = new MemoryStream(viewAssemblyBytes)) + { + return AssemblyLoadContext.Default.LoadFromStream(ms); + } + } + } +} diff --git a/src/Blazor.Host/Host/RazorCompilation.cs b/src/Blazor.Host/Host/RazorCompilation.cs index ab3df21b..b24d449d 100644 --- a/src/Blazor.Host/Host/RazorCompilation.cs +++ b/src/Blazor.Host/Host/RazorCompilation.cs @@ -5,6 +5,8 @@ using System.IO; using System.Collections.Generic; using System.Linq; +using Microsoft.Extensions.Primitives; +using System.Text.RegularExpressions; namespace Blazor.Sdk.Host { @@ -71,6 +73,14 @@ private static async Task ServeCompiledAssembly(HttpContext context, string root var assemblyFilename = requestPath.Substring(requestPath.LastIndexOf('/') + 1); var references = context.Request.Query["reference"]; + // Serve the assembly + context.Response.ContentType = "application/octet-steam"; + var compiledAssembly = GetCompiledViewsAssembly(rootDir, assemblyFilename, references); + await context.Response.Body.WriteAsync(compiledAssembly, 0, compiledAssembly.Length); + } + + internal static byte[] GetCompiledViewsAssembly(string rootDir, string assemblyFilename, IEnumerable references) + { // Get or create cached compilation result. Doesn't really matter that we might be blocking // other request threads with this lock, as this is a development-time feature only. byte[] compiledAssembly; @@ -85,9 +95,7 @@ private static async Task ServeCompiledAssembly(HttpContext context, string root compiledAssembly = cachedCompilationResults[cacheKey]; } - // Actually serve it - context.Response.ContentType = "application/octet-steam"; - await context.Response.Body.WriteAsync(compiledAssembly, 0, compiledAssembly.Length); + return compiledAssembly; } private static byte[] PerformCompilation(string assemblyFilename, string rootDir, IEnumerable additionalReferenceAssemblies) @@ -116,11 +124,10 @@ private static byte[] PerformCompilation(string assemblyFilename, string rootDir private static string InferMainAssemblyFilename(string viewsAssemblyFilename) { - const string viewsAssemblySuffix = ".Views.dll"; - if (viewsAssemblyFilename.EndsWith(viewsAssemblySuffix)) + var partBeforeSuffix = Regex.Match(viewsAssemblyFilename, "(.*)(\\.\\d+)\\.Views\\.dll$"); + if (partBeforeSuffix.Success) { - var partBeforeSuffix = viewsAssemblyFilename.Substring(0, viewsAssemblyFilename.Length - viewsAssemblySuffix.Length); - return $"{partBeforeSuffix}.dll"; + return $"{partBeforeSuffix.Groups[1].Value}.dll"; } return null; diff --git a/src/Blazor.Host/wwwroot/_framework/Blazor.Runtime.js b/src/Blazor.Host/wwwroot/_framework/Blazor.Runtime.js index 2aee8d0f..83cf1f37 100644 --- a/src/Blazor.Host/wwwroot/_framework/Blazor.Runtime.js +++ b/src/Blazor.Host/wwwroot/_framework/Blazor.Runtime.js @@ -8,7 +8,13 @@ Alert: function(message) { alert(message); - }, + }, + + ResolveRelativeUrl: function (url) { + var a = document.createElement('a'); + a.href = url; + return a.cloneNode(false).href; + }, RenderComponent: function(descriptor) { var item = JSON.parse(descriptor); @@ -632,7 +638,8 @@ function DispatchEvent(evt, componentRef, vdomItemIndex) { function OnLocationChanged(pathAndQuery) { InvokeStatic('Blazor.Runtime', 'Blazor.Routing', 'Router', 'OnNavigation', JSON.stringify({ - url: pathAndQuery + url: pathAndQuery, + absoluteUrl: location.href })); // Highlight links to this location diff --git a/src/Blazor.Runtime/Components/BlazorContext.cs b/src/Blazor.Runtime/Components/BlazorContext.cs new file mode 100644 index 00000000..238cc6c1 --- /dev/null +++ b/src/Blazor.Runtime/Components/BlazorContext.cs @@ -0,0 +1,12 @@ +namespace Blazor.Runtime.Components +{ + public class BlazorContext + { + public string AbsoluteUrl { get; private set; } + + public BlazorContext(string absoluteUrl) + { + AbsoluteUrl = absoluteUrl; + } + } +} diff --git a/src/Blazor.Runtime/Components/Component.cs b/src/Blazor.Runtime/Components/Component.cs index fa098226..7972df48 100644 --- a/src/Blazor.Runtime/Components/Component.cs +++ b/src/Blazor.Runtime/Components/Component.cs @@ -4,6 +4,8 @@ using Blazor.VirtualDom; using System.Collections.Generic; using System.Threading.Tasks; +using Blazor.Runtime; +using Blazor.Runtime.Components; namespace Blazor.Components { @@ -17,6 +19,9 @@ public abstract class Component : IDisposable protected virtual string Layout => null; internal Component BodyComponent { get; set; } + private Task _firstRenderCompletedTask; + internal Task FirstRenderCompletedTask => _firstRenderCompletedTask; + // Try to find ways of encapsulating this better. Currently, derived components can interfere with this directly. protected readonly VDomBuilder builder = new VDomBuilder(); @@ -28,6 +33,8 @@ public abstract class Component : IDisposable private Dictionary _children = new Dictionary(); private bool _isDisposed; + public BlazorContext Context { get; internal set; } + internal static Component FindById(int id) { // Returns null if not known or already garbage collected @@ -61,9 +68,10 @@ private Component Mount(string elementRef, bool replace, bool enableLayouts) if (enableLayouts && !string.IsNullOrEmpty(Layout)) { - var layoutComponent = RazorComponent.Instantiate(Layout); + var layoutComponent = RazorComponent.Instantiate(Layout, Context); layoutComponent.BodyComponent = this; layoutComponent.MountAsPage(elementRef); + return layoutComponent; } else { @@ -74,18 +82,23 @@ private Component Mount(string elementRef, bool replace, bool enableLayouts) Init(); var initAsyncTask = InitAsync(); Render(); - initAsyncTask?.ContinueWith(_ => Render()); + _firstRenderCompletedTask = initAsyncTask?.ContinueWith(_ => { + Render(); + }); + return this; } - - return this; } public void Render() { + builder.Clear(); RenderVirtualDom(); - Element.UpdateContents(_id, builder.PrevItems, builder.Items, _replaceElement); - builder.SwapBuffersAndClear(); + if (Env.IsClient) + { + Element.UpdateContents(_id, builder.PrevItems, builder.Items, _replaceElement); + builder.SwapBuffers(); + } } public virtual void Dispose() @@ -121,7 +134,7 @@ internal Component InstantiateAndRegisterChildComponent(int vdomItemIndex) } else { - childComponent = RazorComponent.Instantiate(vdomItem.ComponentName); + childComponent = RazorComponent.Instantiate(vdomItem.ComponentName, Context); childComponent.ReceiveParameters(builder.ReadAttributes(vdomItemIndex)); } @@ -195,5 +208,22 @@ internal void DispatchEvent(int eventRef, EventInfo eventInfo) // a flag on the EventInfo so you could do @onclick(..., AutoRender: false). Render(); } + + public string AbsoluteUrl(string relativeUrl) + { + if (Env.IsServer) + { + return ServerAbsoluteUrl(relativeUrl); + } + else + { + return Browser.ResolveRelativeUrl(relativeUrl); + } + } + + private string ServerAbsoluteUrl(string relativeUrl) + { + return new Uri(new Uri(Context.AbsoluteUrl), relativeUrl).ToString(); + } } } \ No newline at end of file diff --git a/src/Blazor.Runtime/Components/RazorComponent.cs b/src/Blazor.Runtime/Components/RazorComponent.cs index 9c478b20..646c65df 100644 --- a/src/Blazor.Runtime/Components/RazorComponent.cs +++ b/src/Blazor.Runtime/Components/RazorComponent.cs @@ -3,24 +3,43 @@ using System.IO; using System.Collections.Generic; using System.Threading.Tasks; +using System.Linq; +using Blazor.Routing; +using Blazor.Runtime.Components; namespace Blazor.Components { public abstract class RazorComponent : Component { - public static Component Instantiate(string cshtmlFileName) + public static Component Instantiate(string cshtmlFileName, BlazorContext context) { var razorViewClassName = GetViewClassName(".", cshtmlFileName); - var type = Type.GetType($"Views.{razorViewClassName}"); + var viewTypeName = $"Views.{razorViewClassName}"; + Type viewType; + + if (Router.ViewAssemblies == null) + { + // In DNA, we can search across all loaded assemblies + viewType = Type.GetType(viewTypeName); + } + else + { + // On the server, need to explicitly walk through the supplied list of assemblies + viewType = Router.ViewAssemblies.Select(a => a.GetType(viewTypeName)).Where(t => t != null).FirstOrDefault(); + } // To ensure that the constructor actually runs, use Instantiate from the IComponentRazorViewFactory interface. // For more info on why this is needed, see the comments about it in AddIComponentRazorViewFactoryImplementation // in the RazorRenderer project. - return ((IRazorComponentFactory)Activator.CreateInstance(type)).Instantiate(); + var instance = ((IRazorComponentFactory)Activator.CreateInstance(viewType)).Instantiate(); + instance.Context = context; + return instance; } public static string GetViewClassName(string rootDir, string cshtmlFilename) { + cshtmlFilename = cshtmlFilename.Replace('/', Path.DirectorySeparatorChar); + if (!rootDir.EndsWith(Path.DirectorySeparatorChar.ToString())) { rootDir += Path.DirectorySeparatorChar; @@ -36,7 +55,7 @@ public static string GetViewClassName(string rootDir, string cshtmlFilename) // times they are based on type names. It's all very delicate right now. var relativePath = cshtmlFilename.Substring(rootDir.Length); - return relativePath.Replace(Path.DirectorySeparatorChar, '_').Replace('.', '_'); + return relativePath.Replace(Path.DirectorySeparatorChar, '_').Replace('.', '_').ToLowerInvariant(); } protected override void RenderVirtualDom() diff --git a/src/Blazor.Runtime/Interop/Browser.cs b/src/Blazor.Runtime/Interop/Browser.cs index 54ff7fc5..722491cf 100644 --- a/src/Blazor.Runtime/Interop/Browser.cs +++ b/src/Blazor.Runtime/Interop/Browser.cs @@ -12,5 +12,8 @@ public static class Browser [DllImport(@"browser.js", CharSet = CharSet.Ansi)] public static extern void Alert(string message); + + [DllImport(@"browser.js", CharSet = CharSet.Ansi)] + public static extern string ResolveRelativeUrl(string url); } } diff --git a/src/Blazor.Runtime/Interop/Components.cs b/src/Blazor.Runtime/Interop/Components.cs index 8977b29a..00adc434 100644 --- a/src/Blazor.Runtime/Interop/Components.cs +++ b/src/Blazor.Runtime/Interop/Components.cs @@ -11,18 +11,25 @@ public static class Components { public static int InstantiateComponent(string descriptor) { + // This code path is followed for invocations from the JS side during client-side execution var parsed = MiniJSON.Json.Deserialize(descriptor) as Dictionary; + var elementRef = (string)parsed["elementRef"]; var parentComponentRef = (int)parsed["parentComponentRef"]; var vdomItemIndex = (int)parsed["vdomItemIndex"]; - var elementRef = (string)parsed["elementRef"]; var parentComponent = Component.FindById(parentComponentRef); - var newComponent = parentComponent - .InstantiateAndRegisterChildComponent(vdomItemIndex) - .MountAsComponent(elementRef); - + var newComponent = InstantiateAndMountComponent(elementRef, parentComponent, vdomItemIndex); return newComponent.Id; } + public static Component InstantiateAndMountComponent(string elementRef, Component parentComponent, int vdomItemIndex) + { + // This code path is reached directly during server-side execution (and is called by the client-side code path above) + var newComponent = parentComponent + .InstantiateAndRegisterChildComponent(vdomItemIndex); + newComponent.MountAsComponent(elementRef); + return newComponent; + } + public static int UpdateComponentParameters(string descriptor) { var parsed = MiniJSON.Json.Deserialize(descriptor) as Dictionary; diff --git a/src/Blazor.Runtime/Interop/Env.cs b/src/Blazor.Runtime/Interop/Env.cs new file mode 100644 index 00000000..6efc891c --- /dev/null +++ b/src/Blazor.Runtime/Interop/Env.cs @@ -0,0 +1,14 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace Blazor.Runtime +{ + public static class Env + { + private static bool _isServer = false; + + public static bool IsServer => _isServer; + public static bool IsClient => !_isServer; + } +} diff --git a/src/Blazor.Runtime/Interop/ManagedGCHandle.cs b/src/Blazor.Runtime/Interop/ManagedGCHandle.cs index 7c22ef4c..3f038176 100644 --- a/src/Blazor.Runtime/Interop/ManagedGCHandle.cs +++ b/src/Blazor.Runtime/Interop/ManagedGCHandle.cs @@ -1,4 +1,5 @@ -using System; +using Blazor.Runtime; +using System; using System.Collections.Generic; using System.Runtime.InteropServices; @@ -33,7 +34,14 @@ public class ManagedGCHandle : IDisposable public ManagedGCHandle(T value) { _value = value; - _gcHandle = GCHandle.Alloc(this, GCHandleType.Pinned); + + // Note that on the real .NET (non-DNA) runtimes we can't really pin some of the things we + // want to pin for JS interop, because they they are "non-primitive" types (i.e., hold references + // to things that themselves would still be unpinned). During server-side execution we don't + // actually need to pin anything, because there's no interop outside .NET. During client-side + // execution, everything is (in effect) pinned regardless, because DNA's GC only does mark-sweep + // - it doesn't have any compaction phase. + _gcHandle = GCHandle.Alloc(this, Env.IsServer ? GCHandleType.Normal : GCHandleType.Pinned); } public static ManagedGCHandle FromAddress(int address) @@ -44,7 +52,9 @@ public static ManagedGCHandle FromAddress(int address) public T Value => _value; - public int Address => _gcHandle.AddrOfPinnedObject().ToInt32(); + // As per comment above, we don't really need real pointers when executing on the server. + // Nor can we even obtain one safely. + public int Address => Env.IsServer ? 0 : _gcHandle.AddrOfPinnedObject().ToInt32(); public void Dispose() { diff --git a/src/Blazor.Runtime/Routing/Router.cs b/src/Blazor.Runtime/Routing/Router.cs index 52e44171..e24e9974 100644 --- a/src/Blazor.Runtime/Routing/Router.cs +++ b/src/Blazor.Runtime/Routing/Router.cs @@ -1,5 +1,8 @@ using Blazor.Components; +using Blazor.Runtime.Components; using System.Collections.Generic; +using System.IO; +using System.Reflection; namespace Blazor.Routing { @@ -8,17 +11,23 @@ public static class Router private static string _mountInElementSelector; private static string _currentPageComponentPath; private static Component _currentPageComponent; + public static IEnumerable ViewAssemblies; public static void MountInElement(string selector) { _mountInElementSelector = selector; } - internal static void OnNavigation(string descriptor) + internal static Component OnNavigation(string descriptor) { var parsed = MiniJSON.Json.Deserialize(descriptor) as Dictionary; var url = (string)parsed["url"]; + var absoluteUrl = (string)parsed["absoluteUrl"]; + return MountPageFromUrl(url, new BlazorContext(absoluteUrl)); + } + internal static Component MountPageFromUrl(string url, BlazorContext context) + { // By holding the _currentPageComponent in a static property, we ensure that it doesn't // get GCed while the user can still see and try to interact with it. // TODO: Instead of just using "MountAsPage" which destroys the entire previous element content, @@ -26,8 +35,8 @@ internal static void OnNavigation(string descriptor) // the DOM/vdom up to and including that layout, and just insert the new sequence of child // layouts and the new page into it. _currentPageComponentPath = UrlToComponentPath(url); - _currentPageComponent = RazorComponent - .Instantiate(_currentPageComponentPath) + return _currentPageComponent = RazorComponent + .Instantiate(_currentPageComponentPath, context) .MountAsPage(_mountInElementSelector); } @@ -37,8 +46,8 @@ private static string UrlToComponentPath(string url) { url = url + "Index"; } - - return $".{url}.cshtml"; + + return $".{url.Replace('/', Path.DirectorySeparatorChar)}.cshtml"; } } } diff --git a/src/Blazor.Runtime/VirtualDom/VDomBuilder.cs b/src/Blazor.Runtime/VirtualDom/VDomBuilder.cs index db301485..e2cd4167 100644 --- a/src/Blazor.Runtime/VirtualDom/VDomBuilder.cs +++ b/src/Blazor.Runtime/VirtualDom/VDomBuilder.cs @@ -16,17 +16,19 @@ public class VDomBuilder internal VDomItem[] PrevItems => prevItems; internal VDomItem[] Items => items; - - internal void SwapBuffersAndClear() + + internal void Clear() + { + itemsInUse = 0; + openElementIndices.Clear(); + } + + + internal void SwapBuffers() { - // Swap var otherBuffer = prevItems; prevItems = items; items = otherBuffer; - - // Clear - itemsInUse = 0; - openElementIndices.Clear(); } public void OpenElement(int sourceSeq, string tagName) diff --git a/src/Blazor.Runtime/VirtualDom/VDomItem.cs b/src/Blazor.Runtime/VirtualDom/VDomItem.cs index 8a132d04..0412175f 100644 --- a/src/Blazor.Runtime/VirtualDom/VDomItem.cs +++ b/src/Blazor.Runtime/VirtualDom/VDomItem.cs @@ -4,7 +4,7 @@ namespace Blazor.VirtualDom { - internal struct VDomItem + public struct VDomItem { public VDomItemType ItemType; public int SourceSequence;