You may need to program your custom routing logic by implementing IHttpControllerSelector interface to change default routing behavior. Method SelectController is used to select a controller for a given request - HttpRequestMessage. You would need to return type object for the controller type you want to be used.

On Application Start:

• use Reflection to iterate through all the types in loaded Assembly, check their names, if name ends with "Controller" then add controller's type object into static Dictionary cache variable using special key crafted from full type name's segments to extract preceding namespace part and form a string like this v1.user

• register route in config:

  // Register default route
  config.Routes.MapHttpRoute(
      name: "DefaultApi",
      routeTemplate: "{namespace}/{controller}/{action}"
  );
  

• inject your custom class CustomControllerSelector into routing config:

  config.Services.Replace(typeof(System.Web.Http.Dispatcher.IHttpControllerSelector), new CustomControllerSelector(config)); ...

On Every Request:

the injected CustomControllerSelector.SelectController(HttpRequestMessage request) would get called for you automatically, and from request parameter variable you would need to build that Key = v1.user and use it in that static Dictionary to look up cached controller type object that corresponds to that Key. Done!

Complete Code - CustomControllerSelector.cs :

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Text.RegularExpressions;
using System.Web;
using System.Web.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Dispatcher;
using System.Web.Http.Routing;


    public class CustomControllerSelector : IHttpControllerSelector
    {
        private const string NamespaceKey = "namespace";
        private const string ControllerKey = "controller";

        private readonly HttpConfiguration _configuration;
        private readonly Lazy<Dictionary<string, HttpControllerDescriptor>> _controllers;
        private readonly HashSet<string> _duplicates;

        public CustomControllerSelector(HttpConfiguration config)
        {
            _configuration = config;
            _duplicates = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
            _controllers = new Lazy<Dictionary<string, HttpControllerDescriptor>>(InitializeControllerDictionary);
        }

        private Dictionary<string, HttpControllerDescriptor> InitializeControllerDictionary()
        {
            var dictionary = new Dictionary<string, HttpControllerDescriptor>(StringComparer.OrdinalIgnoreCase);

            // http routing: '/v1/User/SomeAction'  => Controllers.V1.UserController 
            //
            // Create a lookup table where key is "namespace.controller", i.e. "V1.User" or "V2.User"
            // Controllers.V1.UserController => "V1.User"
            //
            IAssembliesResolver assembliesResolver = _configuration.Services.GetAssembliesResolver();
            IHttpControllerTypeResolver controllersResolver = _configuration.Services.GetHttpControllerTypeResolver();

            ICollection<Type> controllerTypes = controllersResolver.GetControllerTypes(assembliesResolver);

            foreach (Type t in controllerTypes)
            {
                var segments = t.Namespace.Split(Type.Delimiter);

                // For the dictionary key, strip "Controller" from the end of the type name.
                // This matches the behavior of DefaultHttpControllerSelector.
                var controllerName = t.Name.Remove(t.Name.Length - DefaultHttpControllerSelector.ControllerSuffix.Length);

                var key = String.Format(CultureInfo.InvariantCulture, "{0}.{1}", segments[segments.Length - 1], controllerName);

                // Check for duplicate keys.
                if (dictionary.Keys.Contains(key))
                {
                    _duplicates.Add(key);
                }
                else
                {
                    dictionary[key] = new HttpControllerDescriptor(_configuration, t.Name, t);  
                }
            }

            // Remove any duplicates from the dictionary, because these create ambiguous matches. 
            // For example, "Foo.V1.ProductsController" and "Bar.V1.ProductsController" both map to "v1.products".
            foreach (string s in _duplicates)
            {
                dictionary.Remove(s); 
            }
            return dictionary;
        }

        // Get a value from the route data, if present.
        private static T GetRouteVariable<T>(IHttpRouteData routeData, string name)
        {
            object result = null;
            if (routeData.Values.TryGetValue(name, out result))
            {
                return (T)result;
            }
            return default(T);
        }

        public HttpControllerDescriptor SelectController(HttpRequestMessage request)
        {
            IHttpRouteData routeData = request.GetRouteData();
            if (routeData == null)
            {
                throw new HttpResponseException(HttpStatusCode.NotFound);
            }

            // Get the namespace and controller variables from the route data.
            string namespaceName = GetRouteVariable<string>(routeData, NamespaceKey);
            if (namespaceName == null)
            {
                throw new HttpResponseException(HttpStatusCode.NotFound);
            }

            string controllerName = GetRouteVariable<string>(routeData, ControllerKey);
            if (controllerName == null)
            {
                throw new HttpResponseException(HttpStatusCode.NotFound);
            }

            // Find a matching controller.
            string key = String.Format(CultureInfo.InvariantCulture, "{0}.{1}", namespaceName, controllerName);

            HttpControllerDescriptor controllerDescriptor;
            if (_controllers.Value.TryGetValue(key, out controllerDescriptor))
            {
                return controllerDescriptor;
            }
            else if (_duplicates.Contains(key))
            {
                throw new HttpResponseException(
                    request.CreateErrorResponse(HttpStatusCode.InternalServerError,
                    "Multiple controllers were found that match this request."));
            }
            else
            {
                throw new HttpResponseException(HttpStatusCode.NotFound);
            }
        }

        public IDictionary<string, HttpControllerDescriptor> GetControllerMapping()
        {
            return _controllers.Value;
        }
    }

Code Fragment from WebApiConfig.cs

If you created Web API project from standard template, then this class should be already in your project. Its method Register is called ONCE on application start. So just make sure you have the following routing config code in there:

public static class WebApiConfig
{
    public static void Register(HttpConfiguration config)
    {
        // Web API configuration and services

        // Web API routes
        config.MapHttpAttributeRoutes();

        // Register default route
        config.Routes.MapHttpRoute(
            name: "DefaultApi",
            routeTemplate: "{namespace}/{controller}/{action}"
        );

        config.Services.Replace(typeof(System.Web.Http.Dispatcher.IHttpControllerSelector), new CustomControllerSelector(config));
    }
}

Credit & References

• This answer has been inspired by this article and code is borrowed almost completely from here
• If you want to be able to fall back to Default Controller Selector logic, then read this SO answer on A) how to "inherit" from Default class and B) how to break into the chain of Services but keep the reference to previous Selector object to be able to call it when there is a need to fall back to default behavior.

...