4

我在让 Web API 处理基于子域的路由时遇到问题。简而言之，我找到了正确的控制器和方法，但是 WebAPI 没有提取子域中的数据令牌。

我在我的场景中有这个：

contoso.myapp.com
fabrikam.myapp.com
{tenant}.myapp.com

所有解析到同一个 ApiController 并且我希望能够提取{tenant}令牌。

我使用了本文中的代码http://blog.maartenballiauw.be/post/2012/06/18/Domain-based-routing-with-ASPNET-Web-API.aspx

但是在撰写本文和 ASP.NET Web Api 退出测试版之间似乎发生了一些变化。文章中的代码依赖于RouteTable.RoutesWeb API 路由配置，HttpConfiguration.Routes这是一个HttpRouteCollection而不是通常的RouteCollection（它实际上是派生的RouteCollection）。

所以我将代码更改为从而HttpRoute不是Route. 这是代码：

https://gist.github.com/3766125

我配置这样的路线

 config.Routes.Add(new HttpDomainRoute(
            name: "test",
            domain: "{tenant}.myapp.com",
            routeTemplate: "test",
            defaults: new { controller = "SomeController", action = "Test" }
        ));

我的请求被路由到正确的控制器。但是，租户数据令牌永远不会被填充（如果我这样做this.Request.GetRouteData()了，我会看到控制器和操作令牌，但看不到租户）。如果我在其上放置断点，GetRouteData则永远不会调用它。

我尝试使用反射器跟踪代码路径，并查看在 HttpRouteCollection 级别调用 GetRouteData 的位置，但似乎枚举的集合为空。不确定常规 ASP.NET 路由和 WEB API 路由之间的集成是如何桥接的，但这让我很困惑。

有任何想法吗？

我现在使用的解决方法是显式调用 GetRouteDataRoute

this.Request.GetRouteData().Route.GetRouteData(this.Request.RequestUri.ToString(), this.Request)

4

2 回答 2

2

感谢您报告问题。我在https://github.com/woloski/AspNetWebApiWithSubdomains使用了您的复制品并进行了一些调试。

这就是它发生的原因。没有被调用，因为它被Web API 中HttpDomainRoute.GetRouteData调用的内部类包装。HttpWebRoute当您使用config.Routes.Add方法添加自定义路由时HttpDomainRoute.GetRouteData，它不会调用 ，而是简单地调用 的System.Web.Routing.Route's实现GetRouteData。这就是为什么您会看到除租户之外的其余参数被正确映射的原因。

我想不出任何简单的解决方法。我可以在http://aspnetwebstack.codeplex.com/上的 codeplex 站点提交问题以跟踪此问题。

于 2012-09-25T08:20:32.937 回答
1

在考虑了更多之后，我有一个解决方法给你。变通方法的基本思想是使用从 Route 派生的路由并将其直接添加到 RouteCollection。这样，我们通过的路由将不再被包裹在 HttpWebRoute 中。

RouteByPassing 处理程序用于解决另一个已知问题。希望这可以帮助。

public static class WebApiConfig
{
    public static void Register(HttpConfiguration config)
    {
        config.Routes.MapHttpRoute(
            name: "DefaultApi",
            routeTemplate: "api/{controller}/{id}",
            defaults: new { id = RouteParameter.Optional }
        );

        RouteTable.Routes.Add("test", new HttpDomainRoute(
            domain: "{tenant}.auth10.com",
            routeTemplate: "test",
            defaults: new { controller = "Values", action = "GetTenant" }
        ));

        config.MessageHandlers.Add(new RouteByPassingHandler());
    }
}

public class RouteByPassingHandler : DelegatingHandler
{
    protected override System.Threading.Tasks.Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, System.Threading.CancellationToken cancellationToken)
    {
        HttpMessageInvoker invoker = new HttpMessageInvoker(new HttpControllerDispatcher(request.GetConfiguration()));
        return invoker.SendAsync(request, cancellationToken);
    }
}

public class HttpDomainRoute
    : Route
{
    private Regex domainRegex;
    private Regex pathRegex;

    public HttpDomainRoute(string domain, string routeTemplate, object defaults, object constraints = null)
        : base(routeTemplate, new RouteValueDictionary(defaults), new RouteValueDictionary(constraints), new RouteValueDictionary(), HttpControllerRouteHandler.Instance)
    {
        this.Domain = domain;
    }

    public string Domain { get; set; }

    public override RouteData GetRouteData(HttpContextBase context) 
    {   
        // Build regex
        domainRegex = CreateRegex(this.Domain);
        pathRegex = CreateRegex(this.Url);

        // Request information
        string requestDomain = context.Request.Headers["Host"];
        if (!string.IsNullOrEmpty(requestDomain))
        {
            if (requestDomain.IndexOf(":") > 0)
            {
                requestDomain = requestDomain.Substring(0, requestDomain.IndexOf(":"));
            }
        }
        else
        {
            requestDomain = context.Request.Url.Host;
        }

        string requestPath = context.Request.AppRelativeCurrentExecutionFilePath.Substring(2) + context.Request.PathInfo;

        // Match domain and route
        Match domainMatch = domainRegex.Match(requestDomain);
        Match pathMatch = pathRegex.Match(requestPath);

        // Route data
        RouteData data = null;
        if (domainMatch.Success && pathMatch.Success)
        {
            data = base.GetRouteData(context);

            // Add defaults first
            if (Defaults != null)
            {
                foreach (KeyValuePair<string, object> item in Defaults)
                {
                    data.Values[item.Key] = item.Value;
                }
            }

            // Iterate matching domain groups
            for (int i = 1; i < domainMatch.Groups.Count; i++)
            {
                Group group = domainMatch.Groups[i];
                if (group.Success)
                {
                    string key = domainRegex.GroupNameFromNumber(i);

                    if (!string.IsNullOrEmpty(key) && !char.IsNumber(key, 0))
                    {
                        if (!string.IsNullOrEmpty(group.Value))
                        {
                            data.Values[key] = group.Value;
                        }
                    }
                }
            }

            // Iterate matching path groups
            for (int i = 1; i < pathMatch.Groups.Count; i++)
            {
                Group group = pathMatch.Groups[i];
                if (group.Success)
                {
                    string key = pathRegex.GroupNameFromNumber(i);

                    if (!string.IsNullOrEmpty(key) && !char.IsNumber(key, 0))
                    {
                        if (!string.IsNullOrEmpty(group.Value))
                        {
                            data.Values[key] = group.Value;
                        }
                    }
                }
            }
        }

        return data;
    }

    public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values) 
    {
        return base.GetVirtualPath(requestContext, RemoveDomainTokens(values));
    }

    private Regex CreateRegex(string source)
    {
        // Perform replacements
        source = source.Replace("/", @"\/?");
        source = source.Replace(".", @"\.?");
        source = source.Replace("-", @"\-?");
        source = source.Replace("{", @"(?<");
        source = source.Replace("}", @">([a-zA-Z0-9_-]*))");

        return new Regex("^" + source + "$");
    }

    private RouteValueDictionary RemoveDomainTokens(RouteValueDictionary values)
    {
        Regex tokenRegex = new Regex(@"({[a-zA-Z0-9_-]*})*-?\.?\/?({[a-zA-Z0-9_-]*})*-?\.?\/?({[a-zA-Z0-9_-]*})*-?\.?\/?({[a-zA-Z0-9_-]*})*-?\.?\/?({[a-zA-Z0-9_-]*})*-?\.?\/?({[a-zA-Z0-9_-]*})*-?\.?\/?({[a-zA-Z0-9_-]*})*-?\.?\/?({[a-zA-Z0-9_-]*})*-?\.?\/?({[a-zA-Z0-9_-]*})*-?\.?\/?({[a-zA-Z0-9_-]*})*-?\.?\/?({[a-zA-Z0-9_-]*})*-?\.?\/?({[a-zA-Z0-9_-]*})*-?\.?\/?");
        Match tokenMatch = tokenRegex.Match(Domain);
        for (int i = 0; i < tokenMatch.Groups.Count; i++)
        {
            Group group = tokenMatch.Groups[i];
            if (group.Success)
            {
                string key = group.Value.Replace("{", "").Replace("}", "");
                if (values.ContainsKey(key))
                    values.Remove(key);
            }
        }

        return values;
    }
}

}

于 2012-09-25T17:47:36.820 回答