Est-il possible de faire une ASP.NET MVC itinéraire basé sur un sous-domaine?

À de capture de la sous-domaine tout en conservant la norme MVC5 des fonctionnalités de routage, utilisez la commande suivante SubdomainRoute classe dérivée de Route.

En outre, SubdomainRoute permet le sous-domaine éventuellement être spécifié comme un paramètre de requête, faire sub.example.com/foo/bar et example.com/foo/bar?subdomain=sub équivalent. Cela vous permet de tester avant de les sous-domaines DNS sont configurés. Le paramètre de requête (lorsqu'en service) est multiplié par le biais de nouveaux liens générés par Url.Action, etc.

Le paramètre de requête permet également de débogage locale avec Visual Studio 2013, sans avoir à configurer avec netsh ou exécuter en tant qu'Administrateur. Par défaut, IIS Express ne lie localhost lorsque la non-élevée; il ne se lient pas à la synonymes de noms d'hôtes comme sous.localtest.moi.

class SubdomainRoute : Route
{
    public SubdomainRoute(string url) : base(url, new MvcRouteHandler()) {}

    public override RouteData GetRouteData(HttpContextBase httpContext)
    {
        var routeData = base.GetRouteData(httpContext);
        if (routeData == null) return null; //Only look at the subdomain if this route matches in the first place.
        string subdomain = httpContext.Request.Params["subdomain"]; //A subdomain specified as a query parameter takes precedence over the hostname.
        if (subdomain == null) {
            string host = httpContext.Request.Headers["Host"];
            int index = host.IndexOf('.');
            if (index >= 0)
                subdomain = host.Substring(0, index);
        }
        if (subdomain != null)
            routeData.Values["subdomain"] = subdomain;
        return routeData;
    }

    public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values)
    {
        object subdomainParam = requestContext.HttpContext.Request.Params["subdomain"];
        if (subdomainParam != null)
            values["subdomain"] = subdomainParam;
        return base.GetVirtualPath(requestContext, values);
    }
}

Pour des raisons de commodité, appeler le MapSubdomainRoute méthode de votre RegisterRoutes méthode, comme vous le feriez un bon vieux MapRoute:

static void MapSubdomainRoute(this RouteCollection routes, string name, string url, object defaults = null, object constraints = null)
{
    routes.Add(name, new SubdomainRoute(url) {
        Defaults = new RouteValueDictionary(defaults),
        Constraints = new RouteValueDictionary(constraints),
        DataTokens = new RouteValueDictionary()
    });
}

Enfin, pour accéder facilement aux sous-domaine (que ce soit à partir d'un vrai sous-domaine ou un paramètre de requête), il est utile de créer un Contrôleur de la classe de base avec ce Subdomain propriété:

protected string Subdomain
{
    get { return (string)Request.RequestContext.RouteData.Values["subdomain"]; }
}

Pour capturer le sous-domaine lors de l'utilisation de API Web, remplacer l'Action Sélecteur d'injecter un subdomain paramètre de requête. Ensuite, utiliser le sous-domaine paramètre de requête dans vos controllers' actions comme ceci:

public string Get(string id, string subdomain)

Cette approche rend le débogage pratique car vous pouvez spécifier le paramètre de requête à la main lors de l'utilisation de localhost au lieu du nom de l'hôte (voir le standard MVC5 de routage répondre pour plus de détails). Ceci est le code de l'Action Sélecteur:

class SubdomainActionSelector : IHttpActionSelector
{
    private readonly IHttpActionSelector defaultSelector;

    public SubdomainActionSelector(IHttpActionSelector defaultSelector)
    {
        this.defaultSelector = defaultSelector;
    }

    public ILookup<string, HttpActionDescriptor> GetActionMapping(HttpControllerDescriptor controllerDescriptor)
    {
        return defaultSelector.GetActionMapping(controllerDescriptor);
    }

    public HttpActionDescriptor SelectAction(HttpControllerContext controllerContext)
    {
        var routeValues = controllerContext.Request.GetRouteData().Values;
        if (!routeValues.ContainsKey("subdomain")) {
            string host = controllerContext.Request.Headers.Host;
            int index = host.IndexOf('.');
            if (index >= 0)
                controllerContext.Request.GetRouteData().Values.Add("subdomain", host.Substring(0, index));
        }
        return defaultSelector.SelectAction(controllerContext);
    }
}

Remplacer l'Action par défaut Sélecteur en ajoutant ceci à WebApiConfig.Register:

config.Services.Replace(typeof(IHttpActionSelector), new SubdomainActionSelector(config.Services.GetActionSelector()));

J'ai créé bibliothèque de sous-domaine de routage lequel vous pouvez créer un itinéraire. Il travaille actuellement pour une .NET de Base 1.1 et .NET Framework 4.6.1 mais sera mis à jour dans un avenir proche. C'est de cette manière est-il de travail:

1) la Carte de sous-domaine de l'itinéraire en Démarrage.cs

public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
    var hostnames = new[] { "localhost:54575" };

    app.UseMvc(routes =>
    {
        routes.MapSubdomainRoute(
            hostnames,
            "SubdomainRoute",
            "{username}",
            "{controller}/{action}",
            new { controller = "Home", action = "Index" });
    )};

2) Contrôleurs/Contrôleur HomeController.cs

public IActionResult Index(string username)
{
    //code
}

3) Que lib vous permettra également de générer des Url et des formes. Code:

@Html.ActionLink("User home", "Index", "Home" new { username = "user1" }, null)

Va générer <a href="http://user1.localhost:54575/Home/Index">User home</a>
URL générée dépendra aussi actuel lieu d'accueil et de schéma.


Vous pouvez également utiliser de l'html helpers pour BeginForm et UrlHelper. Si vous le souhaitez, vous pouvez également utiliser la nouvelle fonctionnalité appelée balise aides (FormTagHelper, AnchorTagHelper)

Cette lib n'a pas de documentation pour l'instant, mais il existe certains tests et échantillons projet alors n'hésitez pas à l'explorer.

Après la définition d'un nouveau gestionnaire d'Itinéraire sur le pays hôte est passé dans l'URL, vous pouvez aller avec l'idée d'un Contrôleur de base qui est de l'existence du Site, il est accessible pour. Il ressemble à ceci:

public abstract class SiteController : Controller {
    ISiteProvider _siteProvider;

    public SiteController() {
        _siteProvider = new SiteProvider();
    }

    public SiteController(ISiteProvider siteProvider) {
        _siteProvider = siteProvider;
    }

    protected override void Initialize(RequestContext requestContext) {
        string[] host = requestContext.HttpContext.Request.Headers["Host"].Split(':');

        _siteProvider.Initialise(host[0]);

        base.Initialize(requestContext);
    }

    protected override void OnActionExecuting(ActionExecutingContext filterContext) {
        ViewData["Site"] = Site;

        base.OnActionExecuting(filterContext);
    }

    public Site Site {
        get {
            return _siteProvider.GetCurrentSite();
        }
    }

}

ISiteProvider est une interface simple:

public interface ISiteProvider {
    void Initialise(string host);
    Site GetCurrentSite();
}

Je vous renvoie aller à Luc Sampson Blog

Y a quelques mois, j'ai développé un attribut qui limite les méthodes ou les contrôleurs de domaines spécifiques.

Il est très facile à utiliser:

[IsDomain("localhost","example.com","www.example.com","*.t1.example.com")]
[HttpGet("RestrictedByHost")]
public IActionResult Test(){}

Vous pouvez également l'appliquer directement sur le contrôleur.

public class IsDomainAttribute : Attribute, Microsoft.AspNetCore.Mvc.Filters.IAuthorizationFilter
{

    public IsDomainAttribute(params string[]  domains)
    {
        Domains = domains;
    }

    public string[] Domains { get; }

    public void OnAuthorization(AuthorizationFilterContext context)
    {
        var host = context.HttpContext.Request.Host.Host;
        if (Domains.Contains(host))
            return;
        if (Domains.Any(d => d.EndsWith("*"))
                && Domains.Any(d => host.StartsWith(d.Substring(0, d.Length - 1))))
            return;
        if (Domains.Any(d => d.StartsWith("*"))
                && Domains.Any(d => host.EndsWith(d.Substring(1))))
            return;

        context.Result = new Microsoft.AspNetCore.Mvc.NotFoundResult();//.ChallengeResult
    }
}

Restriction:
vous ne pouvez pas être en mesure d'avoir les deux mêmes types de routes sur des méthodes différentes avec des filtres
Je veux dire que le suivant peut lancer une exception pour la copie de l'itinéraire:

[IsDomain("test1.example.com")]
[HttpGet("/Test")]
public IActionResult Test1(){}

[IsDomain("test2.example.com")]
[HttpGet("/Test")]
public IActionResult Test2(){}