C# HttpRouteValueDictionary类代码示例

        /// <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);
 }