Dynamic url rewriting with MVC and ASP.Net Core

Question

I am re-writing my FragSwapper.com website (currently in Asp 2.0!) with ASP.Net Core and MVC 6 and I'm trying to do something I would normally have to break out a URL Re-Write tool along with db code and some Redirects but I want to know if there is a "better" way to do it in ASP.Net Core possibly with MVC Routing and Redirecting.

Here are my scenarios...

• URL Accessing the site: [root]

  What to do: Go to the usual [Home] Controller and [Index] View (no [ID]). ...it does this now:

  app.UseMvc(routes =>
  {
    routes.MapRoute(
    name: "default",
    template: "{controller=Home}/{action=Index}/{id?}");
  });
  

• URL Accessing the site: [root]/ControllerName/...yada yada...

  What to do: Go to the Controller, etc...all THIS works too.

• The tricky one: URL Accessing the site: [root]/SomeString

  What to do: Access the database and do some logic to decide if I find an Event ID. If I do I go to [Event] Controller and [Index] View and an [ID] of whatever I found. If not I try to find a Host ID and go to [Home] Controller and [Organization] View with THAT [ID] I found. If I don't find and Event or Host go to the usual [Home] Controller and [Index] View (no [ID]).

The big gotcha here is that I want to Redirect to one of three completely different views in 2 different controllers.

So the bottom line is I want to do some logic when the user comes to my site's root and has a single "/Something" on it and that logic is database driven.

If you understand the question you can stop reading now...If you feel the need to understand why all this logic is needed you can read on for a more detailed context.

My site has basically two modes: Viewing an Event and Not Viewing an Event! There are usually 4 or 5 events running at an one time but most users are only interested in one event but it's a DIFFERENT event every 4 months or so..I have a [Host] entity and each Host holds up to 4 events a year, one at a time. Most users only care about one Host's events.

I'm trying to avoid making a user always go to an event map and find the event and click on it since I have a limit to how many times I can show a map (for free) and it's really not necessary. 99.99% of the time a user is on my site they are on an Event screen, not my Home screens, and are interested in only one event at a time. In the future I want to code it so if they come to my website they go right to their event or a new event from their favorite host so I can avoid a LOT of clicks and focus my [Home] controller pages for newbs...but I don't have auto-login working yet so that's on the back burner.

But for now I want hosts to always have the same url for their events: FragSwapper.com/[Host Abbreviation] ...and know it will always go to their current event which has a different ID every 4 months!!!

Crazy...I know...but technically very easy to do, I just don't know how to do it properly in MVC with how things are done.

Answer 1

Update: ASP.Net Core 1.1

According to the release notes, a new RewriteMiddleware has been created.

This provides several different predefined rewrite options and utility extension methods, which might end up modifying the request path as it has been done in this answer. See for example the implementation of RewriteRule

Specifically to the OP question, you would need to implement your own IRule class (either from scratch or extending an existing one like RewriteRule, which is based on a regex). You would possibly complement it with a new AddMyRule() extension method for RewriteOptions.

---

You can create your own middleware and add it to the request pipeline before the MVC routing.

This allows you to inject your code into the pipeline before the MVC routes are evaluated. This way you will be able to:

1. Inspecting the path in the incoming request
2. Search in the database for an eventId or hostId with the same value
3. If event or host were found, update the incoming request path to Event/Index/{eventId} or Home/Organization/{hostId}
4. Let the next middleware (MVC routing) take care of the request. They would see any changes to the request path made by the previous middleware

For example, create your own EventIdUrlRewritingMiddleware middleware that will try to match the incoming request path against an eventId in the database. If matched, it will change the original request path to Event/Index/{eventId}:

public class EventIdUrlRewritingMiddleware
{
    private readonly RequestDelegate _next;        

    //Your constructor will have the dependencies needed for database access
    public EventIdUrlRewritingMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task Invoke(HttpContext context)
    {
        var path = context.Request.Path.ToUriComponent();

        if (PathIsEventId(path))
        {
            //If is an eventId, change the request path to be "Event/Index/{path}" so it is handled by the event controller, index action
            context.Request.Path = "/Event/Index" + path;
        }

        //Let the next middleware (MVC routing) handle the request
        //In case the path was updated, the MVC routing will see the updated path
        await _next.Invoke(context);

    }

    private bool PathIsEventId(string path)
    {            
        //The real midleware will try to find an event in the database that matches the current path
        //In this example I am just using some hardcoded string
        if (path == "/someEventId")
        {
            return true;
        }

        return false;
    }
}

Then create another class HostIdUrlRewritingMiddleware following the same approach.

Finally add your new middlewares to the pipeline in the Startup.Configure method, making sure they are added before the Routing and MVC middleware:

        app.UseMiddleware<EventIdUrlRewritingMiddleware>();
        app.UseMiddleware<HostIdUrlRewritingMiddleware>();
        app.UseMvc(routes =>
        {
            routes.MapRoute(
                name: "default",
                template: "{controller=Home}/{action=Index}/{id?}");
        });

With this configuration:

• / goes to the HomeController.Index action
• /Home/About goes to the HomeController.About action
• /Event/Index/1 goes to the EventController.Index action id=1
• /someEventId goes to the EventController.Index action, id=someEventId

Please note there are no http redirects involved. When opening /someEventId in the browser there is a single http request and the browser will show /someEventId in the addess bar. (Even if internally the original path was updated)