In this post, I’ll show how to extend the routing logic in ASP.NET Web API, by creating a custom controller selector. Suppose that you want to version your web API by defining URIs like the following:<\/p>\n
\/api\/v1\/products\/<\/p>\n
\/api\/v2\/products\/<\/p>\n
You might try to make this work by creating two different “Products” controllers, and placing them in separate namespaces:<\/p>\n
namespace MyApp.Controllers.V1\n{\n \/\/ Version 1 controller\n public class ProductsController : ApiController { }\n}\n\nnamespace MyApp.Controllers.V2\n{\n \/\/ Version 2 controller\n public class ProductsController : ApiController { }\n}\n<\/pre>\nThe problem with this approach is that Web API finds controllers by class name, ignoring the namespace. So there’s no way to make this work using the default routing logic. Fortunately, Web API makes it easy to change the default behavior.<\/p>\n
The interface that Web API uses to select a controller is IHttpControllerSelector<\/strong>. You can read about the default implementation here<\/a>. The important method on this interface is SelectController<\/strong>, which selects a controller for a given HttpRequestMessage<\/strong>.<\/p>\nFirst, you need to understand a little about the Web API routing process. Routing starts with a route template. When you create a Web API project, it adds a default route template:<\/p>\n
“api\/{controller}\/{id}”<\/p>\n
The parts in curly brackets are placeholders. Here is a URI that matches this template:<\/p>\n
http:\/\/www.example.com\/api\/products\/1<\/p>\n
So in this example, the placeholders have these values:<\/p>\n
\n- controller = products<\/li>\n
- id = 1<\/li>\n<\/ul>\n
The default IHttpControllerSelector<\/strong> uses the value of “controller” to find a controller with a matching name. In this example, “products” would match a controller class named ProductsController. (By convention, you need to add the “Controller” suffix to the class name.)<\/p>\nTo make our namespace scenario work, we’ll use a route template like this:<\/p>\n
“api\/{namespace}\/{controller}\/{id}”<\/p>\n
Here is a matching URI:<\/p>\n
http:\/\/www.example.com\/api\/v1\/products\/1<\/p>\n
And here are the placeholder values:<\/p>\n
\n- namespace = v1<\/li>\n
- controller = products<\/li>\n
- id = 1<\/li>\n<\/ul>\n
Now we can use these values to find a matching controller. First, call GetRouteData<\/strong> to get an IHttpRouteData<\/strong> object from the request:<\/p>\npublic HttpControllerDescriptor SelectController(HttpRequestMessage request)\n{\n IHttpRouteData routeData = request.GetRouteData();\n if (routeData == null)\n {\n throw new HttpResponseException(HttpStatusCode.NotFound);\n }\n\n \/\/ ...\n<\/pre>\nUse IHttpRouteData<\/strong> to look up the values of “namespace” and “controller”. The values are stored in a dictionary as object<\/strong> types. Here is a helper method that returns a route value as a type T<\/em>:<\/p>\nprivate static T GetRouteVariable(IHttpRouteData routeData, string name)\n{\n object result = null;\n if (routeData.Values.TryGetValue(name, out result))\n {\n return (T)result;\n }\n return default(T);\n}\n<\/pre>\nUse this helper function to get the route values as strings:<\/p>\n
string namespaceName = GetRouteVariable<string>(routeData, \"namespace\");\nif (namespaceName == null)\n{\n throw new HttpResponseException(HttpStatusCode.NotFound);\n}\n\nstring controllerName = GetRouteVariable<string>(routeData, \"controller\");\nif (controllerName == null)\n{\n throw new HttpResponseException(HttpStatusCode.NotFound);\n}\n<\/pre>\nNow look for a matching controller type. For example, given “namespace” = “v1” and “controller” = “products”, this would match a controller class with the fully qualified name MyApp.Controllers.V1.ProductsController<\/code>.<\/p>\nTo get the list of controller types in the application, use the IHttpControllerTypeResolver<\/strong> interface:<\/p>\nIAssembliesResolver assembliesResolver = \n _configuration.Services.GetAssembliesResolver();\nIHttpControllerTypeResolver controllersResolver = \n _configuration.Services.GetHttpControllerTypeResolver();\n\nICollection<Type> controllerTypes = \n controllersResolver.GetControllerTypes(assembliesResolver);\n<\/pre>\nThis code performs reflection on all of the assemblies in the app domain. To avoid doing this on every request, it’s a good idea to cache a dictionary of controller types, and use the dictionary for subsequent look ups.<\/p>\n
The last step is to replace the default IHttpControllerSelector<\/strong> with our custom implementation, in the HttpConfiguration.Services<\/strong> collection:<\/p>\n config.Services.Replace(typeof(IHttpControllerSelector), \n new NamespaceHttpControllerSelector(config));\n<\/pre>\n