/// <summary>
        /// Map odata route with query string or header constraints
        /// </summary>
        public static void MapODataRoute(
            this HttpRouteCollection routes,
            string routeName,
            string routePrefix,
            IEdmModel model,
            IODataPathHandler pathHandler,
            IEnumerable<IODataRoutingConvention> routingConventions,
            object queryConstraints,
            object headerConstraints)
        {
            if (routes == null)
            {
                throw new ArgumentNullException("routes");
            }

            string routeTemplate = string.IsNullOrEmpty(routePrefix) ? ODataRouteConstants.ODataPathTemplate : (routePrefix + "/" + ODataRouteConstants.ODataPathTemplate);
            ODataVersionRouteConstraint routeConstraint = new ODataVersionRouteConstraint(pathHandler, model, routeName, routingConventions, queryConstraints, headerConstraints);
            var constraints = new HttpRouteValueDictionary();
            constraints.Add(ODataRouteConstants.ConstraintName, routeConstraint);
            routes.MapHttpRoute(
                routeName,
                routeTemplate,
                defaults: null,
                constraints: constraints);
        }

        public static void Register(HttpConfiguration config)
        {
            // Web API 配置和服务

            // Web API 路由
            config.MapHttpAttributeRoutes();

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{action}/{id}",
                defaults: new { id = RouteParameter.Optional }//,
                //constraints:new{sss=new HttpMethodConstraint(HttpMethod.Post)}

            );
            HttpRouteValueDictionary defaults = new HttpRouteValueDictionary();
            //defaults.Add("controller", "Demo");
            //defaults.Add("action", "Get");
            defaults.Add("val", 0);
            HttpRouteValueDictionary constraints = new HttpRouteValueDictionary();
            constraints.Add("val",new DoubleRouteConstraint());

            HttpRoute route = new HttpRoute("customer/{controller}/{action}/{val}", defaults, constraints);

            config.Routes.Add("CustomerApi",route);
        }

 public static void Register(HttpConfiguration config)
 {
     var emptyDictionary = new HttpRouteValueDictionary();
     // Add our one HttpMessageHandler to the root path.
     config.Routes.MapHttpRoute("index", "", emptyDictionary, emptyDictionary,
         new HelloWorldHandler());
 }

 /// <summary>
 /// Builds an <see cref="IHttpRoute"/>.
 /// </summary>
 /// <param name="routeTemplate">The detokenized route template.</param>
 /// <param name="defaults">The route defaults.</param>
 /// <param name="constraints">The route constraints.</param>
 /// <param name="actions">The actions to invoke for the route.</param>
 /// <returns>The generated <see cref="IHttpRoute"/>.</returns>
 public virtual IHttpRoute BuildHttpRoute(
     string routeTemplate,
     HttpRouteValueDictionary defaults,
     HttpRouteValueDictionary constraints,
     IEnumerable<ReflectedHttpActionDescriptor> actions)
 {
     return new HttpDirectRoute(routeTemplate, defaults, constraints, actions);
 }

 /// <summary>
 /// Route used by the AttributeRouting framework in self-host projects.
 /// </summary>
 public HttpAttributeRoute(string url,
     HttpRouteValueDictionary defaults,
     HttpRouteValueDictionary constraints,
     HttpRouteValueDictionary dataTokens,
     HttpAttributeRoutingConfiguration configuration)
     : base(url, defaults, constraints, dataTokens)
 {
     _configuration = configuration;
 }

 public ODataVersionRouteConstraint(
     string routeName,
     object queryConstraints,
     object headerConstraints)
     : base(routeName)
 {
     QueryStringConstraints = new HttpRouteValueDictionary(queryConstraints);
     HeaderConstraints = new HttpRouteValueDictionary(headerConstraints);
 }

 /// <summary>
 /// Route used by the AttributeRouting framework in self-host projects.
 /// </summary>
 public HttpAttributeRoute(string url,
                           HttpRouteValueDictionary defaults,
                           HttpRouteValueDictionary constraints,
                           HttpRouteValueDictionary dataTokens,
                           HttpConfigurationBase configuration)
     : base(url, defaults, constraints, dataTokens, configuration.MessageHandler)
 {
     _configuration = configuration;
 }

 private static decimal GetPrecedence(string attributeRouteTemplate)
 {
     DefaultInlineConstraintResolver resolver = new DefaultInlineConstraintResolver();
     HttpRouteValueDictionary defaults = new HttpRouteValueDictionary();
     HttpRouteValueDictionary constraints = new HttpRouteValueDictionary();
     string standardRouteTemplate = InlineRouteTemplateParser.ParseRouteTemplate(attributeRouteTemplate,
         defaults, constraints, new DefaultInlineConstraintResolver());
     HttpParsedRoute parsedRoute = HttpRouteParser.Parse(standardRouteTemplate);
     return parsedRoute.GetPrecedence(constraints);
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="ODataRoute" /> class.
 /// </summary>
 /// <param name="routePrefix">The route prefix.</param>
 /// <param name="pathConstraint">The OData path constraint.</param>
 /// <param name="defaults">The default values for the route.</param>
 /// <param name="constraints">The route constraints.</param>
 /// <param name="dataTokens">The data tokens.</param>
 /// <param name="handler">The message handler for the route.</param>
 public ODataRoute(
     string routePrefix,
     ODataPathRouteConstraint pathConstraint,
     HttpRouteValueDictionary defaults,
     HttpRouteValueDictionary constraints,
     HttpRouteValueDictionary dataTokens,
     HttpMessageHandler handler)
     : this(routePrefix, (IHttpRouteConstraint)pathConstraint, defaults, constraints, dataTokens, handler)
 {
 }

        public HttpRoute(string routeTemplate, HttpRouteValueDictionary defaults, HttpRouteValueDictionary constraints, HttpRouteValueDictionary dataTokens)
        {
            _routeTemplate = String.IsNullOrWhiteSpace(routeTemplate) ? String.Empty : routeTemplate;
            _defaults = defaults ?? new HttpRouteValueDictionary();
            _constraints = constraints ?? new HttpRouteValueDictionary();
            _dataTokens = dataTokens ?? new HttpRouteValueDictionary();

            // The parser will throw for invalid routes. 
            _parsedRoute = HttpRouteParser.Parse(_routeTemplate);
        }

        protected bool TestValue(IHttpRouteConstraint constraint, object value)
        {
            HttpRequestMessage httpRequestMessage = new HttpRequestMessage();
            HttpRoute httpRoute = new HttpRoute();
            const string parameterName = "fake";
            HttpRouteValueDictionary values = new HttpRouteValueDictionary { { parameterName, value } };
            const HttpRouteDirection httpRouteDirection = HttpRouteDirection.UriResolution;

            return constraint.Match(httpRequestMessage, httpRoute, parameterName, values, httpRouteDirection);
        }        

 /// <summary>
 /// 
 /// </summary>
 /// <param name="routes"></param>
 /// <param name="name"></param>
 /// <param name="routeTemplate"></param>
 /// <param name="defaults"></param>
 /// <param name="constraints"></param>
 /// <param name="handler"></param>
 /// <param name="namespaces"></param>
 /// <returns></returns>
 public static IHttpRoute MapHttpRoute(this HttpRouteCollection routes, string name, string routeTemplate, object defaults, object constraints, HttpMessageHandler handler, string[] namespaces)
 {
     if (routes == null)
     {
         throw new ArgumentNullException("routes");
     }
     var routeValue = new HttpRouteValueDictionary(new { Namespace = namespaces });//设置路由值  
     var route = routes.CreateRoute(routeTemplate, new HttpRouteValueDictionary(defaults), new HttpRouteValueDictionary(constraints), routeValue, handler);
     routes.Add(name, route);
     return route;
 }  

        public HttpRoute(string routeTemplate, HttpRouteValueDictionary defaults, HttpRouteValueDictionary constraints, HttpRouteValueDictionary dataTokens, HttpMessageHandler handler)
        {
            _routeTemplate = routeTemplate == null ? String.Empty : routeTemplate;
            _defaults = defaults ?? new HttpRouteValueDictionary();
            _constraints = constraints ?? new HttpRouteValueDictionary();
            _dataTokens = dataTokens ?? new HttpRouteValueDictionary();
            Handler = handler;

            // The parser will throw for invalid routes.
            ParsedRoute = HttpRouteParser.Parse(RouteTemplate);
        }

        public void Constructor_IsCaseInsensitive()
        {
            // Arrange
            HttpRouteValueDictionary routeValues = new HttpRouteValueDictionary();

            // Act
            routeValues.Add("KEY", null);

            // Assert
            Assert.True(routeValues.ContainsKey("key"));
        }

 public ODataVersionRouteConstraint(
     IODataPathHandler pathHandler,
     IEdmModel model,
     string routeName,
     IEnumerable<IODataRoutingConvention> routingConventions,
     object queryConstraints,
     object headerConstraints)
     : base(pathHandler, model, routeName, routingConventions)
 {
     QueryStringConstraints = new HttpRouteValueDictionary(queryConstraints);
     HeaderConstraints = new HttpRouteValueDictionary(headerConstraints);
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="HttpDirectRoute" /> class.
 /// </summary>
 /// <param name="routeTemplate">The route template.</param>
 /// <param name="defaults">The default values.</param>
 /// <param name="constraints">The route constraints.</param>
 /// <param name="actions">The actions that are reachable via this route.</param>
 public HttpDirectRoute(
     string routeTemplate,
     HttpRouteValueDictionary defaults,
     HttpRouteValueDictionary constraints,
     IEnumerable<ReflectedHttpActionDescriptor> actions)
     : base(routeTemplate, defaults: defaults, constraints: constraints, dataTokens: null, handler: null)
 {
     if (actions != null)
     {
         Actions = actions.AsArray();
         DataTokens[RouteKeys.ActionsDataTokenKey] = Actions;
     }
 }

        /// <summary>
        /// Maps the specified route template and sets default route values, constraints, and end-point message handler.
        /// </summary>
        /// <param name="routes">A collection of routes for the application.</param>
        /// <param name="name">The name of the route to map.</param>
        /// <param name="routeTemplate">The route template for the route.</param>
        /// <param name="defaults">An object that contains default route values.</param>
        /// <param name="constraints">A set of expressions that specify values for <paramref name="routeTemplate"/>.</param>
        /// <param name="handler">The handler to which the request will be dispatched.</param>
        /// <returns>A reference to the mapped route.</returns>
        public static IHttpRoute MapHttpRoute(this HttpRouteCollection routes, string name, string routeTemplate, object defaults, object constraints, HttpMessageHandler handler)
        {
            if (routes == null)
            {
                throw Error.ArgumentNull("routes");
            }

            HttpRouteValueDictionary defaultsDictionary = new HttpRouteValueDictionary(defaults);
            HttpRouteValueDictionary constraintsDictionary = new HttpRouteValueDictionary(constraints);
            IHttpRoute route = routes.CreateRoute(routeTemplate, defaultsDictionary, constraintsDictionary, dataTokens: null, handler: handler);
            routes.Add(name, route);
            return route;
        }

        /// <summary>
        /// Maps the specified route template and sets default route values, constraints, namespaces, and end-point message handler.
        /// </summary>
        /// <param name="routes">A collection of routes for the application.</param>
        /// <param name="name">The name of the route to map.</param>
        /// <param name="routeTemplate">The route template for the route.</param>
        /// <param name="defaults">An object that contains default route values.</param>
        /// <param name="constraints">A set of expressions that specify values for <paramref name="routeTemplate"/>.</param>
        /// <param name="handler">The handler to which the request will be dispatched.</param>
        /// <returns>A reference to the mapped route.</returns>
        public static Route MapHttpRoute(this RouteCollection routes, string name, string routeTemplate, object defaults, object constraints, HttpMessageHandler handler)
        {
            if (routes == null)
            {
                throw Error.ArgumentNull("routes");
            }

            HttpRouteValueDictionary defaultsDictionary = new HttpRouteValueDictionary(defaults);
            HttpRouteValueDictionary constraintsDictionary = new HttpRouteValueDictionary(constraints);
            HostedHttpRoute httpRoute = (HostedHttpRoute)GlobalConfiguration.Configuration.Routes.CreateRoute(routeTemplate, defaultsDictionary, constraintsDictionary, dataTokens: null, handler: handler);
            Route route = httpRoute.OriginalRoute;
            routes.Add(name, route);
            return route;
        }

        public void GetVirtualPath_GeneratesPathWithoutRouteData()
        {
            var route = new HttpRoute("{controller}");
            var request = new HttpRequestMessage();
            var values = new HttpRouteValueDictionary()
            {
                { "httproute", true },
                { "controller", "Customers" }
            };

            IHttpVirtualPathData virtualPath = route.GetVirtualPath(request, values);

            Assert.NotNull(virtualPath);
            Assert.Equal("Customers", virtualPath.VirtualPath);
        }

        /// <summary>
        /// Maps the specified OData route.
        /// </summary>
        /// <param name="routes">A collection of routes for the application.</param>
        /// <param name="routeName">The name of the route to map.</param>
        /// <param name="routePrefix">The prefix to add to the OData route's path template.</param>
        /// <param name="model">The EDM model to use for parsing OData paths.</param>
        /// <param name="pathHandler">The <see cref="IODataPathHandler"/> to use for parsing the OData path.</param>
        /// <param name="routingConventions">The OData routing conventions to use for controller and action selection.</param>
        public static void MapODataRoute(this HttpRouteCollection routes, string routeName, string routePrefix, IEdmModel model,
            IODataPathHandler pathHandler, IEnumerable<IODataRoutingConvention> routingConventions)
        {
            if (routes == null)
            {
                throw Error.ArgumentNull("routes");
            }

            string routeTemplate = String.IsNullOrEmpty(routePrefix) ?
                ODataRouteConstants.ODataPathTemplate :
                routePrefix + "/" + ODataRouteConstants.ODataPathTemplate;
            IHttpRouteConstraint routeConstraint = new ODataPathRouteConstraint(pathHandler, model, routeName, routingConventions);
            HttpRouteValueDictionary constraintDictionary = new HttpRouteValueDictionary() { { ODataRouteConstants.ConstraintName, routeConstraint } };
            routes.MapHttpRoute(routeName, routeTemplate, defaults: null, constraints: constraintDictionary);
        }