1 using System;
  2 using System.Collections.Generic;
  3 using System.Globalization;
  4 using System.Linq;
  5 using System.Net;
  6 using System.Net.Http;
  7 using System.Text.RegularExpressions;
  8 using System.Web;
  9 using System.Web.Http;
 10 using System.Web.Http.Controllers;
 11 using System.Web.Http.Dispatcher;
 12 using System.Web.Http.Routing;
 13  
 14 namespace NamespaceControllerSelectorSample
 15 {
 16     public class NamespaceHttpControllerSelector : IHttpControllerSelector
 17     {
 18         private const string NamespaceKey = "namespace";
 19         private const string ControllerKey = "controller";
 20  
 21         private readonly HttpConfiguration _configuration;
 22         private readonly Lazy<Dictionary<string, HttpControllerDescriptor>> _controllers;
 23         private readonly HashSet<string> _duplicates;
 24  
 25         public NamespaceHttpControllerSelector(HttpConfiguration config)
 26         {
 27             _configuration = config;
 28             _duplicates = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
 29             _controllers = new Lazy<Dictionary<string, HttpControllerDescriptor>>(InitializeControllerDictionary);
 30         }
 31  
 32         private Dictionary<string, HttpControllerDescriptor> InitializeControllerDictionary()
 33         {
 34             var dictionary = new Dictionary<string, HttpControllerDescriptor>(StringComparer.OrdinalIgnoreCase);
 35  
 36             // Create a lookup table where key is "namespace.controller". The value of "namespace" is the last
 37             // segment of the full namespace. For example:
 38             // MyApplication.Controllers.V1.ProductsController => "V1.Products"
 39             IAssembliesResolver assembliesResolver = _configuration.Services.GetAssembliesResolver();
 40             IHttpControllerTypeResolver controllersResolver = _configuration.Services.GetHttpControllerTypeResolver();
 41  
 42             ICollection<Type> controllerTypes = controllersResolver.GetControllerTypes(assembliesResolver);
 43  
 44             foreach (Type t in controllerTypes)
 45             {
 46                 var segments = t.Namespace.Split(Type.Delimiter);
 47  
 48                 // For the dictionary key, strip "Controller" from the end of the type name.
 49                 // This matches the behavior of DefaultHttpControllerSelector.
 50                 var controllerName = t.Name.Remove(t.Name.Length - DefaultHttpControllerSelector.ControllerSuffix.Length);
 51  
 52                 var key = String.Format(CultureInfo.InvariantCulture, "{0}.{1}", segments[segments.Length - 1], controllerName);
 53  
 54                 // Check for duplicate keys.
 55                 if (dictionary.Keys.Contains(key))
 56                 {
 57                     _duplicates.Add(key);
 58                 }
 59                 else
 60                 {
 61                     dictionary[key] = new HttpControllerDescriptor(_configuration, t.Name, t); 
 62                 }
 63             }
 64  
 65             // Remove any duplicates from the dictionary, because these create ambiguous matches.
 66             // For example, "Foo.V1.ProductsController" and "Bar.V1.ProductsController" both map to "v1.products".
 67             foreach (string s in _duplicates)
 68             {
 69                 dictionary.Remove(s);
 70             }
 71             return dictionary;
 72         }
 73  
 74         // Get a value from the route data, if present.
 75         private static T GetRouteVariable<T>(IHttpRouteData routeData, string name)
 76         {
 77             object result = null;
 78             if (routeData.Values.TryGetValue(name, out result))
 79             {
 80                 return (T)result;
 81             }
 82             return default(T);
 83         }
 84  
 85         public HttpControllerDescriptor SelectController(HttpRequestMessage request)
 86         {
 87             IHttpRouteData routeData = request.GetRouteData();
 88             if (routeData == null)
 89             {
 90                 throw new HttpResponseException(HttpStatusCode.NotFound);
 91             }
 92  
 93             // Get the namespace and controller variables from the route data.
 94             string namespaceName = GetRouteVariable<string>(routeData, NamespaceKey);
 95             if (namespaceName == null)
 96             {
 97                 throw new HttpResponseException(HttpStatusCode.NotFound);
 98             }
 99  
100             string controllerName = GetRouteVariable<string>(routeData, ControllerKey);
101             if (controllerName == null)
102             {
103                 throw new HttpResponseException(HttpStatusCode.NotFound);
104             }
105  
106             // Find a matching controller.
107             string key = String.Format(CultureInfo.InvariantCulture, "{0}.{1}", namespaceName, controllerName);
108  
109             HttpControllerDescriptor controllerDescriptor;
110             if (_controllers.Value.TryGetValue(key, out controllerDescriptor))
111             {
112                 return controllerDescriptor;
113             }
114             else if (_duplicates.Contains(key))
115             {
116                 throw new HttpResponseException(
117                     request.CreateErrorResponse(HttpStatusCode.InternalServerError,
118                     "Multiple controllers were found that match this request."));
119             }
120             else
121             {
122                 throw new HttpResponseException(HttpStatusCode.NotFound);
123             }
124         }
125  
126         public IDictionary<string, HttpControllerDescriptor> GetControllerMapping()
127         {
128             return _controllers.Value;
129         }
130     }
131 }