Add HttpRouteTableBuilder for SelfHost.

Author: panesofglass

src/WebApiContrib.SelfHost/Routing/HttpRouteTableBuilder.cs

@@ -0,0 +1,153 @@
+using System;
+using System.Linq;
+using System.Reflection;
+using System.Text.RegularExpressions;
+using System.Web.Http;
+using System.Web.Http.Routing;
+using WebApiContrib.Routing;
+
+namespace WebApiContrib.SelfHost.Routing
+{
+    /// <summary>
+    /// Route table builder that uses the <see cref="HttpRouteAttribute"/> instances found on the controllers
+    /// in the web application.
+    /// </summary>
+    public class HttpRouteTableBuilder
+    {
+        /// <summary>
+        /// Builds a route table based on the Http route 
+        /// attributes found on the controllers in the current web application.
+        /// </summary>
+        /// <param name="routes">Route collection to append the routes to</param>
+        public static void BuildTable(HttpRouteCollection routes)
+        {
+            var assembly = Assembly.GetExecutingAssembly();
+            BuildTable(routes, assembly);
+        }
+
+        /// <summary>
+        /// Builds a route table based on the Http route 
+        /// attributes found on the controllers in the current web application.
+        /// </summary>
+        /// <param name="routes">Route collection to append the routes to</param>
+        /// <param name="assembly">Assembly to scan for routes</param>
+        public static void BuildTable(HttpRouteCollection routes, Assembly assembly)
+        {
+            var controllerTypes = assembly.GetExportedTypes().Where(type => typeof(ApiController).IsAssignableFrom(type));
+
+            // Find all the controller types and extract the HTTP route attributes from 
+            // the public methods that can be found on the controller.
+            foreach (var controllerType in controllerTypes)
+            {
+                BuildControllerRoutes(routes, controllerType);
+
+                var methods = controllerType.GetMethods(BindingFlags.Public | BindingFlags.Instance);
+
+                foreach (var method in methods)
+                {
+                    BuildControllerMethodRoutes(routes, controllerType, method);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Builds the contents for the route table based on the attributes
+        /// found on a specific controller type.
+        /// </summary>
+        /// <param name="routes"></param>
+        /// <param name="controllerType"></param>
+        private static void BuildControllerRoutes(HttpRouteCollection routes, Type controllerType)
+        {
+            var attributes = (HttpRouteAttribute[]) controllerType.GetCustomAttributes(typeof(HttpRouteAttribute), true);
+
+            string controller = controllerType.Name;
+
+            // Translate the somewhat weird controller name into one the routing system
+            // understands, by removing the Controller part from the name.
+            if (controller.EndsWith("Controller", StringComparison.Ordinal))
+            {
+                controller = controller.Substring(0, controller.IndexOf("Controller"));
+            }
+
+            foreach (var attribute in attributes)
+            {
+                var routeValuesDictionary = new HttpRouteValueDictionary();
+                routeValuesDictionary.Add("controller", controller);
+
+                // Create the route and attach the default route handler to it.
+            	var route = new HttpRoute(attribute.UriTemplate, routeValuesDictionary, new HttpRouteValueDictionary(), new HttpRouteValueDictionary());
+
+                routes.Add(Guid.NewGuid().ToString(), route);
+            }
+        }
+
+        /// <summary>
+        /// Builds the contents for the route table based on the attributes
+        /// found on the method of a specific controller.
+        /// </summary>
+        /// <param name="routes"></param>
+        /// <param name="controllerType"></param>
+        /// <param name="method"></param>
+        private static void BuildControllerMethodRoutes(HttpRouteCollection routes, Type controllerType, MethodInfo method)
+        {
+            // Grab the http route attributes from the current method.
+            var attributes = (HttpRouteAttribute[]) method.GetCustomAttributes(typeof(HttpRouteAttribute), true);
+
+            if (attributes.Length != 0)
+            {
+                // Automatically grab the controller name and action name
+                // from the method and controller type.
+                string action = method.Name;
+                string controller = controllerType.Name;
+
+                // Translate the somewhat weird controller name into one the routing system
+                // understands, by removing the Controller part from the name.
+                if (controller.EndsWith("Controller", StringComparison.Ordinal))
+                {
+                    controller = controller.Substring(0, controller.IndexOf("Controller"));
+                }
+
+                // Generate a route for every HTTP route attribute found on the method
+                foreach (var attribute in attributes)
+                {
+                    var routeValueDictionary = new HttpRouteValueDictionary();
+
+                    routeValueDictionary.Add("controller", controller);
+                    routeValueDictionary.Add("action", action);
+
+                    ResolveOptionalRouteParameters(attribute.UriTemplate, method, routeValueDictionary);
+
+                    // Create the route and attach the default route handler to it.
+                    var route = new HttpRoute(attribute.UriTemplate, routeValueDictionary, new HttpRouteValueDictionary(), new HttpRouteValueDictionary());
+
+                    routes.Add(Guid.NewGuid().ToString(), route);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Resolves any route parameters that have been marked as optional
+        /// </summary>
+        /// <param name="uriTemplate"></param>
+        /// <param name="method"></param>
+        /// <param name="routeValueDictionary"></param>
+        private static void ResolveOptionalRouteParameters(string uriTemplate, MethodInfo method, HttpRouteValueDictionary routeValueDictionary)
+        {
+            Regex pattern = new Regex(@"{(\S+)}");
+            var methodParameters = method.GetParameters();
+
+            foreach (Match match in pattern.Matches(uriTemplate))
+            {
+                string parameterName = match.Groups[1].Value;
+                var parameter = methodParameters.FirstOrDefault(param => param.Name == parameterName);
+
+                // Mark the route parameter as optional when there's a method parameter for it
+                // and that method parameter is marked with [OptionalRouteParameter]
+                if (parameter != null && parameter.GetCustomAttributes(typeof(OptionalRouteParameterAttribute), true).Length != 0)
+                {
+                    routeValueDictionary.Add(parameterName, RouteParameter.Optional);
+                }
+            }
+        }
+    }
+}

src/WebApiContrib.SelfHost/WebApiContrib.SelfHost.csproj

@@ -51,7 +51,6 @@
       <HintPath>..\..\packages\Microsoft.Net.Http.2.0.20504.0\lib\net40\System.Net.Http.WebRequest.dll</HintPath>
     </Reference>
     <Reference Include="System.ServiceModel" />
-    <Reference Include="System.Web" />
     <Reference Include="System.Web.Http, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
       <Private>True</Private>
       <HintPath>..\..\packages\Microsoft.AspNet.WebApi.Core.4.0.20504.0\lib\net40\System.Web.Http.dll</HintPath>
@@ -60,7 +59,6 @@
       <Private>True</Private>
       <HintPath>..\..\packages\Microsoft.AspNet.WebApi.SelfHost.4.0.20504.0\lib\net40\System.Web.Http.SelfHost.dll</HintPath>
     </Reference>
-    <Reference Include="System.Web.Routing" />
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />
     <Reference Include="Microsoft.CSharp" />
@@ -69,6 +67,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Routing\HttpRouteTableBuilder.cs" />
     <Compile Include="SslHttpSelfHostConfiguration.cs" />
   </ItemGroup>
   <ItemGroup>