remove razor files and optimize cascading value creation process

Author: hez2010

BlazorRouter.Sample/BlazorRouter.Sample.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk.Web">
+<Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
@@ -7,10 +7,13 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Hez2010.BlazorRouter" Version="1.0.0" />
     <PackageReference Include="Microsoft.AspNetCore.Blazor" Version="3.0.0-preview6.19307.2" />
     <PackageReference Include="Microsoft.AspNetCore.Blazor.Build" Version="3.0.0-preview6.19307.2" PrivateAssets="all" />
     <PackageReference Include="Microsoft.AspNetCore.Blazor.DevServer" Version="3.0.0-preview6.19307.2" PrivateAssets="all" />
   </ItemGroup>
 
+  <ItemGroup>
+    <ProjectReference Include="..\BlazorRouter\BlazorRouter.csproj" />
+  </ItemGroup>
+
 </Project>

BlazorRouter/BlazorRouter.csproj

@@ -16,7 +16,7 @@
     <PackageId>Hez2010.BlazorRouter</PackageId>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
     <Product>BlazorRouter</Product>
-    <Version>1.0.0</Version>
+    <Version>1.0.1</Version>
     <PackageRequireLicenseAcceptance>False</PackageRequireLicenseAcceptance>
     <Company>hez2010</Company>
   </PropertyGroup>

BlazorRouter/Route.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Components;
+
+namespace BlazorRouter
+{
+    public class Route : ComponentBase
+    {
+        [CascadingParameter(Name = "SwitchInstance")] protected Switch SwitchInstance { get; set; }
+        [Parameter] public string Template { get; set; } = "";
+        [Parameter] public RenderFragment ChildContent { get; set; }
+
+        private bool hasRegisterd = false;
+
+        protected override Task OnParametersSetAsync()
+        {
+            if (!hasRegisterd)
+            {
+                hasRegisterd = true;
+                base.OnParametersSetAsync();
+                if (SwitchInstance == null)
+                {
+                    throw new InvalidOperationException("A Route markup must be included in a Switch markup.");
+                }
+                return SwitchInstance.RegisterRoute(ChildContent, Template);
+            }
+            return Task.CompletedTask;
+        }
+    }
+}

BlazorRouter/Route.razor

@@ -0,0 +1,112 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components.RenderTree;
+using Microsoft.AspNetCore.Components.Routing;
+
+namespace BlazorRouter
+{
+    public class Switch : ComponentBase, IDisposable
+    {
+        private int CreateCascadingValue<T>(RenderTreeBuilder builder, int seq, T value, string name, RenderFragment child)
+        {
+            builder.OpenComponent<CascadingValue<T>>(seq++);
+            builder.AddAttribute(seq++, "Value", value);
+            builder.AddAttribute(seq++, "Name", name);
+            builder.AddAttribute(seq++, "ChildContent", child);
+            builder.CloseComponent();
+            return seq;
+        }
+        protected override void BuildRenderTree(RenderTreeBuilder builder)
+        {
+            var seq = 0;
+
+            seq = CreateCascadingValue(builder, seq, this, "SwitchInstance", ChildContent);
+            CreateCascadingValue(builder, seq, parameters, "RouteParameters", currentFragment);
+        }
+
+        [Inject] private IUriHelper UriHelper { get; set; }
+        [Inject] private INavigationInterception NavigationInterception { get; set; }
+        [Inject] private IComponentContext ComponentContext { get; set; }
+        [Parameter] public RenderFragment ChildContent { get; set; }
+        [Parameter] public EventHandler<RouteMatchedEventArgs> OnMatch { get; set; }
+
+        private readonly RouteTable routes = new RouteTable();
+        private bool navigationInterceptionEnabled;
+        private string location = "";
+        private string baseUri = "";
+        private RenderFragment currentFragment;
+        private IDictionary<string, object> parameters;
+
+        static readonly char[] queryOrHashStartChar = new[] { '?', '#' };
+        private async void LocationChanged(object sender, LocationChangedEventArgs e)
+        {
+            this.location = e.Location;
+
+            await SwitchContent(e.IsNavigationIntercepted);
+        }
+
+        private string StringUntilAny(string str, char[] chars)
+        {
+            var firstIndex = str.IndexOfAny(chars);
+            return firstIndex < 0 ? str : str.Substring(0, firstIndex);
+        }
+
+        private Task SwitchContent(bool isNavigationIntercepted)
+        {
+            var path = UriHelper.ToBaseRelativePath(this.baseUri, this.location);
+            path = "/" + StringUntilAny(path, queryOrHashStartChar);
+
+            var context = new RouteContext(path);
+            routes.Route(context);
+
+            if (context.Fragment != null)
+            {
+                currentFragment = context.Fragment;
+                parameters = context.Parameters;
+                OnMatch?.Invoke(this, new RouteMatchedEventArgs(this.location, context.TemplateText, context.Parameters, context.Fragment));
+
+                this.StateHasChanged();
+            }
+            else
+            {
+                if (isNavigationIntercepted)
+                {
+                    UriHelper.NavigateTo(this.location, forceLoad: true);
+                }
+            }
+
+            return Task.CompletedTask;
+        }
+
+        protected override Task OnInitAsync()
+        {
+            this.baseUri = UriHelper.GetBaseUri();
+            this.location = UriHelper.GetAbsoluteUri();
+            UriHelper.OnLocationChanged += LocationChanged;
+            return Task.CompletedTask;
+        }
+
+        public Task RegisterRoute(RenderFragment fragment, string template)
+        {
+            routes.Add(template, fragment);
+            return Task.CompletedTask;
+        }
+
+        protected override async Task OnAfterRenderAsync()
+        {
+            if (!this.navigationInterceptionEnabled && ComponentContext.IsConnected)
+            {
+                this.navigationInterceptionEnabled = true;
+                await SwitchContent(false);
+                await NavigationInterception.EnableNavigationInterceptionAsync();
+            }
+        }
+
+        public void Dispose()
+        {
+            UriHelper.OnLocationChanged -= LocationChanged;
+        }
+    }
+}