Domain-based routing in ASP.NET Core 2.0

Question

I have an ASP.NET Core 2.0 app hosted on an Azure App Service.

This application is bound to domainA.com. I have one route in my app—for example, domainA.com/route.

Now, I want to introduce another domain, but have it respond only to a different route—for example, domainB.com.

What is the best way to do this?

Answer 1

Built-in Approach

Since ASP.NET Core 3—and with continued support in ASP.NET Core 5 and 6—you can restrict individual route definitions to specific hostnames by using the RequireHost() extension method, as discussed in Allow routing to areas by hostname. (Contrary to the issue title, this isn't specific to areas.)

Example

So, to adapt @nightowl888's example in the accepted answer, you can now accomplish the same result without having to define a custom IRouteConstraint:

app.UseMvc(routes =>
{

  routes.MapRoute(
    name: "DomainA",
    template: "route",
    defaults: new { controller = "DomainA", action = "Route" }
  ).RequireHost("domaina.com");

  routes.MapRoute(
    name: "DomainB",
    template: "route",
    defaults: new { controller = "DomainB", action = "Route" }
  ).RequireHost("domainb.com");

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

});

Attribute Routing

Alternatively, if you prefer attribute routing, as used in @yanga's approach, you can now use the new (but poorly documented) HostAttribute (source code):

[Host("domainb.com")]
public DomainController: Controller
{
  … 
}

Obviously, this doesn't address the original problem, which was for ASP.NET Core 2. As this is an un(der)documented feature, however, I wanted to leave it here for people trying to solve this problem for ASP.NET Core 3+.

Answer 2

One way to accomplish this is to make a custom route constraint to specify which routes function for each domain name.

DomainConstraint

    public class DomainConstraint : IRouteConstraint
    {
        private readonly string[] domains;

        public DomainConstraint(params string[] domains)
        {
            this.domains = domains ?? throw new ArgumentNullException(nameof(domains));
        }

        public bool Match(HttpContext httpContext, IRouter route, string routeKey, RouteValueDictionary values, RouteDirection routeDirection)
        {
            string domain =
#if DEBUG
                // A domain specified as a query parameter takes precedence 
                // over the hostname (in debug compile only).
                // This allows for testing without configuring IIS with a 
                // static IP or editing the local hosts file.
                httpContext.Request.Query["domain"];
#else
                null;
#endif
            if (string.IsNullOrEmpty(domain))
                domain = httpContext.Request.Host.Host;

            return domains.Contains(domain);
        }
    }

Usage

app.UseMvc(routes =>
{
    routes.MapRoute(
        name: "DomainA",
        template: "route",
        defaults: new { controller = "DomainA", action = "Route" },
        constraints: new { _ = new DomainConstraint("domaina.com") });

    routes.MapRoute(
        name: "DomainB",
        template: "route",
        defaults: new { controller = "DomainB", action = "Route" },
        constraints: new { _ = new DomainConstraint("domainb.com") });

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

Note that if you fire this up in Visual Studio it won't work with the standard configuration. To allow for easy debugging without changing the configuration, you can specify the URL with the domain as a query string parameter:

/route?domain=domaina.com

This is just so you don't have to reconfigure IIS and your local hosts file to debug (although you still can if you prefer that way). During a Release build this feature is removed so it will only work with the actual domain name in production.

Since routes respond to all domain names by default, it only makes sense to do it this way if you have a large amount of functionality that is shared between domains. If not, it is better to setup separate areas for each domain:

routes.MapRoute(
    name: "DomainA",
    template: "{controller=Home}/{action=Index}/{id?}",
    defaults: new { area = "DomainA" },
    constraints: new { _ = new DomainConstraint("domaina.com") }
);

routes.MapRoute(
    name: "DomainA",
    template: "{controller=Home}/{action=Index}/{id?}",
    defaults: new { area = "DomainB" },
    constraints: new { _ = new DomainConstraint("domainb.com") }
);

Answer 3

For .net Core MVC, you can create a new IRouteConstraint and a RouteAttribute

=> IRouteConstraint.cs

using System;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;

namespace Microsoft.AspNetCore.Routing
{
    public class ConstraintHost : IRouteConstraint
    {

        public string _value { get; private set; }
        public ConstraintHost(string value)
        {
            _value = value;
        }

        public bool Match(HttpContext httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection)
        {
            string hostURL = httpContext.Request.Host.ToString();
            if (hostURL == _value)
            {
                return true;
            }
            //}
            return false;
            //return hostURL.IndexOf(_value, StringComparison.OrdinalIgnoreCase) >= 0;
        }

        public bool Match(HttpContext httpContext, IRouter route, string routeKey, RouteValueDictionary values, RouteDirection routeDirection)
        {
            throw new NotImplementedException();
        }
    }
    public class ConstraintHostRouteAttribute : RouteAttribute
    {
        public ConstraintHostRouteAttribute(string template, string sitePermitted)
            : base(template)
        {
            SitePermitted = sitePermitted;
        }

        public RouteValueDictionary Constraints
        {
            get
            {
                var constraints = new RouteValueDictionary();
                constraints.Add("host", new ConstraintHost(SitePermitted));
                return constraints;
            }
        }

        public string SitePermitted
        {
            get;
            private set;
        }
    }
} 

And in your Controller can use it like that:

    [ConstraintHostRoute("myroute1/xxx", "domaina.com")]
    [ConstraintHostRoute("myroute2/yyy", "domainb.com")]
    public async Task<ActionResult> MyController()
    {
      return View();
    }