Integrate RCL Pages in Blazor Server with Dynamic Loading

To make routes like /dashboard from your WebPortal.Module.Dashboard Razor Class Library (RCL) work in a modular Blazor Server app, add the dynamically loaded assemblies from AssemblyScanning.GetAssemblies() to both the Router’s AdditionalAssemblies in Routes.razor and MapRazorComponents.AddAdditionalAssemblies() in Program.cs. This dual registration ensures Blazor routing discovers @page "/dashboard" directives in RCL Blazor pages at runtime, fixing the “Sorry, there’s nothing at this address” 404 without build errors. Your current setup scans correctly but misses endpoint mapping in the app pipeline—it’s a common gotcha after .NET 8 upgrades.

Contents

• Understanding Blazor Server Routing and Blazor Pages from Razor Class Libraries
• Setting Up Blazor Razor Components in RCL for Modular Apps
• Dynamic Assembly Loading with AssemblyScanning for Blazor Route Discovery
• Configuring Router AdditionalAssemblies in Routes.razor
• Registering RCL Assemblies in Program.cs with MapRazorComponents
• Troubleshooting Blazor Routing 404 Errors in .NET 8+ Blazor Server
• Best Practices for Blazor Components and Modular Blazor Server Apps
• Sources
• Conclusion

Understanding Blazor Server Routing and Blazor Pages from Razor Class Libraries

Blazor Server apps handle routing through a Router component that scans assemblies for @page directives, generating RouteAttribute metadata for paths like /dashboard. When you pull Blazor pages from an RCL like WebPortal.Module.Dashboard, the host app (WebPortal.UI) won’t automatically know about them—especially in modular setups with dynamic loading.

Think about it: your Pages/Dashboard.razor has @page "/dashboard", but without explicit assembly references, the router treats it like a ghost. Blazor routing relies on two layers: client-side discovery via Router AdditionalAssemblies for interactive navigation, and server-side endpoint mapping via MapRazorComponents for HTTP requests. Skip either, and you get that frustrating not-found page. According to the official Blazor routing docs, RCL integration demands adding these assemblies to both spots for full coverage.

Why does this trip people up? Static references work fine in simple apps, but your bin-scanning approach for WebPortal.Module.* modules loads them at runtime. No errors during build—just silence at /dashboard.

Setting Up Blazor Razor Components in RCL for Modular Apps

Start in your RCL. Ensure WebPortal.Module.Dashboard is a Razor Class Library project targeting .NET 8+. Add Pages/Dashboard.razor with a proper @page directive:

@page "/dashboard"
@rendermode InteractiveServer

<PageTitle>Dashboard</PageTitle>

<h1>Dashboard Loaded!</h1>
<p>This proves Blazor pages from RCL work with routing.</p>

Don’t forget the @rendermode if you’re using interactive server rendering—it’s picky in .NET 8 Blazor Server. Your RCL needs <Project Sdk="Microsoft.NET.Sdk.Razor"> in the .csproj, plus any shared _Imports.razor for @using directives.

Assets like CSS or JS? Drop them in wwwroot—they’ll serve via /_content/WebPortal.Module.Dashboard/. The Blazor class libraries guide confirms this setup makes components discoverable, but routing still needs host config. Pro tip: Implement IModule in a class like DashboardModule : IModule for your scanning filter. It’ll validate loaded assemblies later.

Quick test: Build the RCL, drop the DLL in bin, and reference it statically in WebPortal.UI. If /dashboard works, your RCL is solid—the issue is dynamic loading.

Dynamic Assembly Loading with AssemblyScanning for Blazor Route Discovery

Your AssemblyScanning.cs is on the right track. Here’s a refined version that scans bin/Debug/net8.0 (or bin/ in prod), loads WebPortal.Module.* DLLs, and filters IModule implementers:

using System.Reflection;

public static class AssemblyScanning
{
 public static IEnumerable<Assembly> GetAssemblies()
 {
 var binPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)!;
 var moduleAssemblies = Directory
 .GetFiles(binPath, "WebPortal.Module.*.dll", SearchOption.AllDirectories)
 .Select(AssemblyLoadContext.Default.LoadFromAssemblyPath)
 .Where(asm => asm.GetTypes().Any(t => t.IsAssignableTo(typeof(IModule))))
 .ToArray();

 return moduleAssemblies.Concat(new[] { typeof(Program).Assembly }); // Include host too
 }
}

This grabs your dashboard module dynamically. But scanning alone doesn’t register routes—Blazor needs the assemblies fed to the router and pipeline. A Stack Overflow thread on .NET 8 RCL routing nails it: runtime loading works, but forget the mappings, and 404s persist.

Load early? Call this in Program.cs startup or a scoped service if needed. Handles upgrades from .NET 7 where endpoint discovery changed.

Configuring Router AdditionalAssemblies in Routes.razor

Your Routes.razor snippet is close. Tweak it to ensure scanning happens before render:

@using WebPortal.UI.Helpers
@inject IWebAssemblyHostEnvironment? HostingEnvironment

<Router AppAssembly="@typeof(Program).Assembly" 
 NotFound="@typeof(Pages.NotFound)"
 AdditionalAssemblies="@(AssemblyScanning.GetAssemblies().ToArray())">
 <Found Context="routeData">
 <RouteView RouteData="@routeData" DefaultLayout="@typeof(Layout.MainLayout)" />
 <FocusOnNavigate RouteData="@routeData" Selector="h1" />
 </Found>
</Router>

Injecting the environment helps in some edge cases, but the key is ToArray() for the immutable list. This tells the client-side router to scan RCLs for RouteAttribute on /dashboard. Test by navigating via link—should render interactively.

Still 404 on direct URL? That’s server-side. Next up: Program.cs.

Registering RCL Assemblies in Program.cs with MapRazorComponents

Here’s the missing piece. Update Program.cs to mirror the router:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorComponents()
 .AddInteractiveServerComponents();

var app = builder.Build();

// Load assemblies early
var moduleAssemblies = AssemblyScanning.GetAssemblies().ToArray();

app.MapRazorComponents<App>()
 .AddInteractiveServerRenderMode()
 .AddAdditionalAssemblies(moduleAssemblies); // Critical line!

app.Run();

Chain .AddAdditionalAssemblies(moduleAssemblies) on MapRazorComponents—it maps RCL endpoints like /dashboard for HTTP. Without it, SignalR handles interactive bits, but direct fetches fail. The .NET 9 routing fallback docs stress this for modular Blazor Server.

Rebuild, hit /dashboard. Boom—dashboard loads.

Troubleshooting Blazor Routing 404 Errors in .NET 8+ Blazor Server

Not working yet? Check these:

• Assembly load fails? Log AssemblyScanning.GetAssemblies()—ensure DLLs are in bin and IModule implemented.
• Render mode mismatch? Add @rendermode InteractiveServer to RCL pages.
• .NET 8 upgrade quirks? Clear bin/obj, verify <ImplicitUsings>enable</ImplicitUsings> in projects.
• Static files? RCL wwwroot serves fine, but confirm no route conflicts.
• Debug trick: Add logging: builder.Logging.AddConsole(); and trace IRazorComponentsServiceProvider.

Common pitfall: Scanning too late. Make GetAssemblies() static and call once. If SSR fallback kicks in, force interactive via AddInteractiveServerRenderMode().AddAdditionalAssemblies(...).

Best Practices for Blazor Components and Modular Blazor Server Apps

• Scan once: Cache assemblies in a singleton service.
• Version modules: Use semantic versioning for WebPortal.Module.*.
• Lazy load: For heavy modules, defer scanning until first nav.
• Security: Validate loaded types before registration.
• Testing: Mock AssemblyScanning for unit tests.

Modular Blazor shines here—scale to dozens of RCLs without monolith bloat. Keep namespaces clean with @using WebPortal.Module.Dashboard in host _Imports.razor.

Sources

1. Blazor Routing Fundamentals — Official guide on Router AdditionalAssemblies and RCL route discovery: https://learn.microsoft.com/en-us/aspnet/core/blazor/fundamentals/routing?view=aspnetcore-8.0
2. Blazor .NET 8 RCL Routing Issue — Stack Overflow solution for 404s with MapRazorComponents chaining: https://stackoverflow.com/questions/77836160/blazor-in-net-8-routing-issue-when-load-page-from-razor-class-library
3. Blazor Components in Class Libraries — Documentation on RCL setup, assets, and integration: https://learn.microsoft.com/en-us/aspnet/core/blazor/components/class-libraries?view=aspnetcore-8.0
4. Blazor Routing .NET 9 — Advanced routing with dynamic assemblies and render modes: https://learn.microsoft.com/en-us/aspnet/core/blazor/fundamentals/routing?view=aspnetcore-9.0&viewFallbackFrom=aspnetcore-8.0

Conclusion

Dual registration—Router plus MapRazorComponents—is the unlock for Blazor Server routing with dynamic RCLs like your dashboard module. Implement the code tweaks, scan reliably, and /dashboard will light up without 404s. Scale modularly, test rigorously, and you’ve got a flexible Blazor app ready for growth. If quirks persist, log your assemblies—it’s usually a load timing hiccup.