As a temporary hack, I'm using something like this:

    public class DynamicRouter : Router
    {
        delegate object RouteTableCreateDelegate(IEnumerable<Type> types);

        private static readonly RouteTableCreateDelegate RouteTableCreate;
        private static readonly PropertyInfo SetRoutes;
        private static readonly MethodInfo Refresh;

        static DynamicRouter()
        {
            // Lots of reflection to get at internal/private methods
            // NOTE: This will most likely (100%) break on Blazor updates later.
            var asm = typeof(Router).Assembly;

            Type FindType(string type) => asm.GetTypes().FirstOrDefault(t => t.Name == type);

            MethodInfo Find(Type type, string method) => type?
                                                         .GetMethods(BindingFlags.Instance |
                                                                     BindingFlags.Static |
                                                                     BindingFlags.Public |
                                                                     BindingFlags.NonPublic)
                                                         .FirstOrDefault(m => m.Name == method);

            MethodInfo FindMethod(string type, string method) => Find(FindType(type), method);
            
            // public static RouteTable Create(IEnumerable<Type> types)
            RouteTableCreate = (RouteTableCreateDelegate) FindMethod("RouteTable", "Create")?.CreateDelegate(typeof(RouteTableCreateDelegate));
            if (RouteTableCreate == null)
                Console.WriteLine("RouteTable.Create was not found");

            SetRoutes = typeof(Router).GetProperty("Routes", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
            if (SetRoutes == null)
                Console.WriteLine("Router.Routes was not found");

            Refresh = typeof(Router).GetMethod("Refresh", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
            if (Refresh == null)
                Console.WriteLine("Router.Refresh was not found");
        }

        // Basically, any time an assembly gets loaded, refresh the routes list
        // This isn't the best method, but it works, and realistically, assembly loads are pretty few and far between
        public DynamicRouter() => AppDomain.CurrentDomain.AssemblyLoad += RefreshRoutes;
        
        private void RefreshRoutes(object sender, AssemblyLoadEventArgs args)
        {
            Console.WriteLine("Assembly loaded: " + args.LoadedAssembly.GetName().Name);

            // ComponentResolver does an ass-backwards way of resolving the components in an assembly.
            // It's their way of "walking" the dependency tree. But it's totally broken.
            // That's the main reason why the router isn't dynamic.
            var components = AppDomain.CurrentDomain.GetAssemblies()
                                      .Where(a=>!a.IsDynamic)
                                      .SelectMany(a => a.ExportedTypes.Where(t => typeof(IComponent).IsAssignableFrom(t) && !t.IsAbstract))
                                      .ToList();

            Console.WriteLine("Found " + components.Count + " components");
            foreach(var component in components.Where(c=>c.GetCustomAttribute(typeof(Microsoft.AspNetCore.Components.RouteAttribute)) != null))
                Console.WriteLine(component.FullName);

            var routes = RouteTableCreate(components);

            SetRoutes.SetValue(this, routes);
        }
    }

It's not perfect, but it at least lets me forcefully reload routes from newly loaded assemblies.

My note about the ComponentResolver is the main reason why we can't have truly dynamic routes.

How to register plugin routes with router? #1

Description

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions