Ist es möglich, einen ASP.NET MVC-route, basierend auf einer subdomain?

Zu erfassen die subdomain, unter Beibehaltung der standard-MVC5-routing-Funktionen, verwenden Sie die folgende SubdomainRoute Klasse abgeleitet Route.

Darüber hinaus SubdomainRoute ermöglicht die subdomain Optional angegeben werden als query-parameter, so dass sub.example.com/foo/bar und example.com/foo/bar?subdomain=sub entspricht. Dies ermöglicht Ihnen zu testen, bevor die DNS-subdomains konfiguriert sind. Die Abfrage-parameter (wenn in Gebrauch) wird vermehrt durch neue links generiert Url.Action usw.

Den query-parameter ermöglicht auch das lokale Debuggen mit Visual Studio 2013 ohne Konfiguration mit netsh oder als Administrator ausführen. Standardmäßig wird IIS Express bindet nur an localhost, wenn nicht erhöht; es wird nicht binden Synonym Hostnamen wie sub.localtest.mir.

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);
    }
}

Für die Bequemlichkeit, rufen Sie die folgende MapSubdomainRoute Methode von Ihrem RegisterRoutes Methode genauso, als würden Sie plain old 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()
    });
}

Schließlich, um bequem Zugriff auf die subdomain (entweder aus einem echten subdomain oder ein query-parameter), ist es hilfreich, einen Domänencontroller zu erstellen Basisklasse mit diesem Subdomain Eigenschaft:

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

InformationsquelleAutor Edward Brey

Erfassen die subdomain bei Verwendung Web-API, überschreiben die Aktion Selektor, um zu injizieren, eine subdomain query-parameter. Verwenden Sie dann die subdomain query-parameter in den Controller " Aktionen wie diese:

public string Get(string id, string subdomain)

Dieser Ansatz macht das Debuggen praktisch, da können Sie die Abfrage-parameter von hand bei der Verwendung localhost anstelle des tatsächlichen host-Namen (siehe standard MVC5 routing Antwort für details). Dies ist der code für Action Selector:

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);
    }
}

Ersetzen Sie die Standard-Aktion Selektor, indem diese WebApiConfig.Register:

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

InformationsquelleAutor Edward Brey

Ich erstellt Bibliothek für subdomain-routing die Sie erstellen können, eine solche route. Er arbeitet derzeit für eine .NET Core 1.1 und .NET Framework 4.6.1 wird aber aktualisiert werden, in Naher Zukunft. Dies ist, wie es funktioniert:

1) Anzeigen subdomain-route im Startup.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) Controller/HomeController.cs

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

3), Die lib wird auch ermöglichen es Ihnen, URLs generieren und Formen. Code:

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

Generiert <a href="http://user1.localhost:54575/Home/Index">User home</a>
Generierte URL wird auch davon abhängen, aktuellen host-Standort und schema.


Sie können auch html-Helfer für BeginForm und UrlHelper. Wenn Sie möchten, können Sie auch verwenden neues feature namens tag Helfer (FormTagHelper, AnchorTagHelper)

Dass die lib nicht, habe alle Unterlagen noch, aber es gibt einige tests und Proben Projekt so fühlen sich frei, um es zu erkunden.

InformationsquelleAutor Mariusz

Nach der Definition einer neuen Route-handler, der schaut auf die host-URL übergeben, können Sie gehen mit der Idee, einen Basis-Controller, die bewusst von der Seite ist es, auf die zugegriffen wird. Es sieht wie folgt aus:

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 ist eine einfache Schnittstelle:

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

Verweise ich Sie gehen zu Luke Sampson Blog

InformationsquelleAutor Amirhossein Mehrvarzi

Ich vor einigen Monaten entwickelt haben, ist ein Attribut, das schränkt Methoden oder Controller auf bestimmte Domänen.

Es ist ganz einfach zu verwenden:

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

Können Sie den Antrag auch direkt auf einen controller.

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
    }
}

Einschränkung:
Sie möglicherweise nicht in der Lage sein, zwei gleiche Strecken auf unterschiedlichen Methoden mit verschiedenen filtern
Ich meine die folgenden möglicherweise eine Ausnahme für die doppelte Strecke:

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

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

InformationsquelleAutor Jean