Using attribute routing and convention based routing with Web API and MVC simultaneously

Question

I have an Asp.net MVC web application that uses convention based routing. I recently added some Web Api 2 controllers, for which I used attribute routing. Despite the documentation claiming that you can use both, I can either get the (attribute routed) API methods to work, or the (convention routed) web application methods.

This is RouteConfig.RegisterRoutes():

    public static void RegisterRoutes(RouteCollection routes)
    {
        routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

        //routes.MapMvcAttributeRoutes();

        routes.MapRoute(
            name: "Default",
            url: "{controller}/{action}/{id}",
            defaults: new { controller = "Tables", action = "Index", id = UrlParameter.Optional },
            namespaces: new string[] { "Foo.Cms.Controllers" }
        );
    }

This is WebApiConfig.Register():

    public static void Register(HttpConfiguration config)
    {
        config.MapHttpAttributeRoutes();

        // Uncomment the following line of code to enable query support for actions with an IQueryable or IQueryable<T> return type.
        // To avoid processing unexpected or malicious queries, use the validation settings on QueryableAttribute to validate incoming queries.
        // For more information, visit http://go.microsoft.com/fwlink/?LinkId=279712.
        //config.EnableQuerySupport();


        // The models currently only serialize succesfully to xml, so we'll remove the json formatter.
        GlobalConfiguration.Configuration.Formatters.Remove(GlobalConfiguration.Configuration.Formatters.JsonFormatter);
    }

And this is Application_Start():

    protected void Application_Start()
    {
        AreaRegistration.RegisterAllAreas();

        FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
        GlobalConfiguration.Configure(WebApiConfig.Register);
        RouteConfig.RegisterRoutes(RouteTable.Routes);

        BundleConfig.RegisterBundles(BundleTable.Bundles);
        AuthConfig.RegisterAuth();

        GlobalConfiguration.Configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
    }

This way, only the routing to the web api controllers works. If I switch GlobalConfiguration.Register() and RouteConfig.RegisterRoutes(), like so:

        RouteConfig.RegisterRoutes(RouteTable.Routes);
        GlobalConfiguration.Configure(WebApiConfig.Register);

...only the convention-based routing works.

I'm at a loss. What's going on here?

Edit:

What I'm trying to achieve:

The application currently uses the basic {controller}/{action}/parameters convention. So I have a controller called ElementsController that has, for instance, an Index() method that is routed to /Elements or a ListPublic() method that is routed to /Elements/ListPublic. I achieved this with the convention based routing mentioned above.

I also have a bunch of Web Api controllers (for instance, TablesController) that I want to route to using a /api/v0/tables route. I tried to achieve this like so:

[RoutePrefix("api/v0/tables")]
public class TablesController : ApiController
{
    [Route()]
    public string Get()
    {
        // ...
    }
}

As you can see, it's not the same route pattern: api calls are all prefixed with api/v0/. For some reason though, it still appears to treat them as the default {controller}/{action} routes.

Answer 1

What's occurring is that the "first registered" route is taking effect. If I have a MVC route defined as {controller}/{action}/{id}

and a Web API route defined as

{controller}/{action}/{id}

The first registered route will take effect.

Why is this the case? Imagine you send a request to the server

foo/bar/1

Which route does this match?

Both!

It will choose the first result that matches the route regardless of the type of routing used . If you want some examples as to how to make these routings work, check out this link

Answer 2

If an URL matches two different route templates, it doesn't matter if they refer to MVC or Web API, the only rule is that the first registered route will be used to select the action to execute.

In yur particular case, if you make a GET request to this URL: /api/v0/tables , the action selector starts checking the registered routes.

The first route that you're registering is an MVC route like this: /{controller}/{action}/{id} . So, the template matches with this values:

controller = "api"
action = "v0"
id = "tables"

If you register the attribute routes before the MVC route, the first matching route template will be your route attribute template, so the Web API controller action will be correctly selected.

In other words, if you need to route Web API and MVC in the same application you have to use routes which match different URLs for each action, and be careful with the order in which they are registered: register first the more specific templates, and then the more generic ones, so that the generic templates doesn't swallow the URIs which should be matched with the specific templates.

This is not the only option. You can also use route constraints, for example, if all your API has a particular naming convention which can be checked with a constraint (for example a Regex constraint), you can still use convention routing for Web API.

NOTE: apart from the route matching, it's also necessary that the HTTP method (like POST, GET, etc.) is supported by the action. So you can have two similar actions in the same route that accept different methods, and the Action selector would know which one to choose, but this doesn't solve your problem