C# HttpConfiguration.EnableQuerySupport方法代码示例

        public static void RegisterWebApiRoutes(HttpConfiguration config)
        {
            config.Routes.MapHttpRoute(
                name: "AccountApi",
                routeTemplate: "api/account/{action}/{id}",
                defaults: new { controller = "Account",  id = RouteParameter.Optional }
            );

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );

            config.Routes.MapHttpRoute(
                name: "BreezeDefault",
                routeTemplate: "breeze/{action}",
                defaults: new { Controller = "Metadata" }
            );

            config.Routes.MapHttpRoute(
                name: "BreezeModule",
                routeTemplate: "breeze/{controller}/{action}"
            );

            config.EnableQuerySupport();
        }

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

            // Web API routes
            config.MapHttpAttributeRoutes();

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );

            var cors = new EnableCorsAttribute("*", "*", "*");
            config.EnableCors(cors);

            // Uncomment the following line of code to enable query support for actions with an IQueryable or IQueryable<T> return type.
            // To avoid processing unexpected or malicious queries, use the validation settings on QueryableAttribute to validate incoming queries.
            // For more information, visit http://go.microsoft.com/fwlink/?LinkId=279712.
            //config.EnableQuerySupport();

            var modelBuilder = new ODataConventionModelBuilder();
            modelBuilder.EntitySet<Song>("Songs");
            modelBuilder.EntitySet<Artist>("Artists");
            modelBuilder.EntitySet<Album>("Albums");

            var json = config.Formatters.JsonFormatter;
            json.SerializerSettings.PreserveReferencesHandling = PreserveReferencesHandling.Objects;

            var model = modelBuilder.GetEdmModel();
            config.Routes.MapODataRoute("odata", "odata", model);
            config.EnableQuerySupport();
        }

        public void Configuration(IAppBuilder appBuilder)
        {
            HttpConfiguration config = new HttpConfiguration ();

            config.Routes.MapHttpRoute(
                name: "AdminApi",
                routeTemplate: "admin/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );

            config.Routes.MapHttpRoute(
                name: "GenericDataApi",
                routeTemplate: "{controller}/{database}/{collection}/{id}",  // controller always == "data"
                defaults: new { id = RouteParameter.Optional }
            );

            config.Routes.MapHttpRoute(
                name: "AppServicesApi",
                routeTemplate: "{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );

            //config.Formatters.JsonFormatter.SerializerSettings.Converters.Add(new DynamicBsonDocumentJsonConverter());
            config.Formatters.JsonFormatter.SerializerSettings.Converters.Add(new BsonDocumentJsonConverter());
            config.Formatters.JsonFormatter.SerializerSettings.Converters.Add(new CursorJsonConverter());

            config.EnableQuerySupport();

            appBuilder.UseWebApi (config);
        }

        public static void Register(HttpConfiguration config)
        {
            config.Routes.MapHttpRoute(
            name: "UsersApi",
            routeTemplate: "api/users/{action}",
            defaults: new
            {
                controller = "users"
            });

            config.Routes.MapHttpRoute(
            name: "CommentsApi",
            routeTemplate: "api/comments/{action}",
            defaults: new
            {
                controller = "comments"
            });

            config.Routes.MapHttpRoute(
            name: "FeedApi",
            routeTemplate: "api/feeds/{id}",
            defaults: new {
                controller="feeds",
                id = RouteParameter.Optional
            });

            // Uncomment the following line of code to enable query support for actions with an IQueryable or IQueryable<T> return type.
            // To avoid processing unexpected or malicious queries, use the validation settings on QueryableAttribute to validate incoming queries.
            // For more information, visit http://go.microsoft.com/fwlink/?LinkId=279712.
            config.EnableQuerySupport();

            // To disable tracing in your application, please comment out or remove the following line of code
            // For more information, refer to: http://www.asp.net/web-api
            config.EnableSystemDiagnosticsTracing();
        }

        public static void Register(HttpConfiguration config)
        {
            ODataModelBuilder builder = new ODataConventionModelBuilder();

            //builder.EntitySet<Entities.Models.Customer>(typeof(Entities.Models.Customer).Name);
            //builder.EntitySet<Entities.Models.Order>(typeof(Entities.Models.Order).Name);

            //var orderDetailBuilder = builder.EntitySet<Entities.Models.OrderDetail>(typeof(Entities.Models.OrderDetail).Name);
            //orderDetailBuilder.EntityType.HasKey(x => x.ProductID);

            //var customerDemographicBuilder = builder.EntitySet<Entities.Models.CustomerDemographic>(typeof(Entities.Models.CustomerDemographic).Name);
            //customerDemographicBuilder.EntityType.HasKey(x => x.CustomerDesc);

            //var productBuilder = builder.EntitySet<Entities.Models.Product>(typeof(Entities.Models.Product).Name);
            //productBuilder.EntityType.HasKey(t => t.ProductID);

            //builder.EntitySet<Entities.Models.Category>(typeof(Entities.Models.Category).Name);
            //builder.EntitySet<Entities.Models.Supplier>(typeof(Entities.Models.Supplier).Name);

            //builder.EntitySet<Entities.Models.Employee>(typeof(Entities.Models.Employee).Name);
            //builder.EntitySet<Entities.Models.Shipper>(typeof(Entities.Models.Shipper).Name);

        //    var model = builder.GetEdmModel();
         //   config.Routes.MapODataRoute("odata", "odata", model);

            config.EnableQuerySupport();
        }

        public static void Register(HttpConfiguration config)
        {
            config.Routes.MapHttpRoute(
              name: "FeaturesByProjectApi",
              routeTemplate: "api/projects/{projectId}/features",
              defaults: new { controller = "projects", action = "GetFeatures", id = RouteParameter.Optional }
            );
            config.Routes.MapHttpRoute(
                name: "GetTaskPerStatusApi",
                routeTemplate: "api/projects/{projectId}/tasksperstatus",
                defaults: new { controller = "projects", action = "GetTaskPerStatus", id = RouteParameter.Optional }
                );
            config.Routes.MapHttpRoute(
                name: "FinishedTaskPerDayApi",
                routeTemplate: "api/projects/{projectId}/FinishedTaskPerDay",
                defaults: new { controller = "projects", action = "GetFinishedTaskPerDay", id = RouteParameter.Optional }
                );
            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );

            

            // Uncomment the following line of code to enable query support for actions with an IQueryable or IQueryable<T> return type.
            // To avoid processing unexpected or malicious queries, use the validation settings on QueryableAttribute to validate incoming queries.
            // For more information, visit http://go.microsoft.com/fwlink/?LinkId=279712.
            config.EnableQuerySupport();

            // To disable tracing in your application, please comment out or remove the following line of code
            // For more information, refer to: http://www.asp.net/web-api
            config.EnableSystemDiagnosticsTracing();
        }

        public static void Register(HttpConfiguration config)
        {
            ODataModelBuilder modelBuilder = new ODataConventionModelBuilder();
            modelBuilder.EntitySet<Post>("Posts");

            Microsoft.Data.Edm.IEdmModel model = modelBuilder.GetEdmModel();
            config.Routes.MapODataRoute("ODataRoute", "odata", model);

            config.EnableQuerySupport();

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );

            // Uncomment the following line of code to enable query support for actions with an IQueryable or IQueryable<T> return type.
            // To avoid processing unexpected or malicious queries, use the validation settings on QueryableAttribute to validate incoming queries.
            // For more information, visit http://go.microsoft.com/fwlink/?LinkId=279712.
            //config.EnableQuerySupport();

            // To disable tracing in your application, please comment out or remove the following line of code
            // For more information, refer to: http://www.asp.net/web-api
            config.EnableSystemDiagnosticsTracing();
        }

        public static void Register(HttpConfiguration config)
        {
            // Web API configuration and services
            // Configure Web API to use only bearer token authentication.
            config.SuppressDefaultHostAuthentication();
            config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));
            config.Filters.Add(new NotImplExceptionFilterAttribute());
            config.Filters.Add(new ValidateModelAttribute());

            // Web API routes
            var constraintResolver = new DefaultInlineConstraintResolver();
            constraintResolver.ConstraintMap.Add("nonezero", typeof(NoneZeroConstraint));
            config.MapHttpAttributeRoutes(constraintResolver);

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );

            config.Formatters.Add(new ProductCsvFormatter());
            config.EnableQuerySupport();

            //var provider = new SimpleModelBinderProvider(typeof(Product), new ProductModelBinder());
            //config.Services.Insert(typeof(ModelBinderProvider), 0, provider);

            DtoMapperConfig.CreateMaps();
        }

        public static void Register(HttpConfiguration config)
        {
            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );

            // Uncomment the following line of code to enable query support for actions with an IQueryable or IQueryable<T> return type.
            // To avoid processing unexpected or malicious queries, use the validation settings on QueryableAttribute to validate incoming queries.
            // For more information, visit http://go.microsoft.com/fwlink/?LinkId=279712.
            config.EnableQuerySupport();

            // To disable tracing in your application, please comment out or remove the following line of code
            // For more information, refer to: http://www.asp.net/web-api
            config.EnableSystemDiagnosticsTracing();

            //var json = config.Formatters.JsonFormatter;
            //json.SerializerSettings.PreserveReferencesHandling = PreserveReferencesHandling.Objects;
            //config.Formatters.Remove(config.Formatters.XmlFormatter);

            //config.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;

            //config.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Serialize; 
            //config.Formatters.JsonFormatter.SerializerSettings.PreserveReferencesHandling = PreserveReferencesHandling.Objects;
        }

        public static void Register(HttpConfiguration config)
        {
            config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;

            // Add $format support
            config.MessageHandlers.Add(new FormatQueryMessageHandler());

            // Add NavigationRoutingConvention2 to support POST, PUT, PATCH and DELETE on navigation property
            var conventions = ODataRoutingConventions.CreateDefault();
            conventions.Insert(0, new CustomNavigationRoutingConvention());

            // Enables OData support by adding an OData route and enabling querying support for OData.
            // Action selector and odata media type formatters will be registered in per-controller configuration only
            config.Routes.MapODataRoute(
                routeName: "OData",
                routePrefix: null,
                model: ModelBuilder.GetEdmModel(),
                pathHandler: new DefaultODataPathHandler(),
                routingConventions: conventions);

            // Enable queryable support and allow $format query
            config.EnableQuerySupport(new QueryableAttribute
            {
                AllowedQueryOptions = AllowedQueryOptions.Supported | AllowedQueryOptions.Format
            });

            // To disable tracing in your application, please comment out or remove the following line of code
            // For more information, refer to: http://www.asp.net/web-api
            config.EnableSystemDiagnosticsTracing();

            config.Filters.Add(new ModelValidationFilterAttribute());
        }

        /// <summary>
        ///     Configures http message handlers.
        /// </summary>
        /// <param name="configuration"></param>
        public static void Configure(HttpConfiguration configuration)
        {
            // Attribute routes
            configuration.MapHttpAttributeRoutes();

            // Message handlers
            configuration.MessageHandlers.Add(new MethodOverrideHandler());
            configuration.MessageHandlers.Add(new UserAgentOverrideHandler());
            configuration.MessageHandlers.Add(new CancelledTaskBugWorkaroundMessageHandler());

            // Media type formatters
            configuration.Formatters.Clear();
            configuration.Formatters.Add(new JsonMediaTypeFormatter { SerializerSettings = { ContractResolver = new CamelCasePropertyNamesContractResolver() } });
            configuration.Formatters.Add(new FormUrlEncodedMediaTypeFormatter());
            configuration.Formatters.Add(new JQueryMvcFormUrlEncodedFormatter());
            configuration.Formatters.Add(new MultipartFormFormatter());
            configuration.Formatters.Add(new AnyOtherTypeFormFormatter());
            configuration.Formatters.Add(new ProjectForAdminCsvFormatter());
            configuration.Formatters.Add(new UserForAdminCsvFormatter());
            configuration.Formatters.Add(new ClientForAdminCsvFormatter());

            // CORS support
            configuration.EnableQuerySupport();
            configuration.EnableCors();
        }

        public static void Register(HttpConfiguration config)
        {
            // Web API configuration and services
            // Configure Web API to use only bearer token authentication.
            config.SuppressDefaultHostAuthentication();
            config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));

            var corsConfig = new EnableCorsAttribute("*", "*", "*");
            //corsConfig.SupportsCredentials = true;   //not allowed with * origin
            config.EnableCors(corsConfig);

            config.EnableQuerySupport();

            config.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
            config.Formatters.JsonFormatter.SerializerSettings.PreserveReferencesHandling = PreserveReferencesHandling.None;
            config.Formatters.JsonFormatter.SerializerSettings.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
            config.Formatters.JsonFormatter.SerializerSettings.DateFormatHandling = DateFormatHandling.IsoDateFormat;
            config.Formatters.JsonFormatter.SerializerSettings.Converters.Add(new StringEnumConverter { CamelCaseText = false });
            config.Formatters.Remove(config.Formatters.XmlFormatter);

            config.MapHttpAttributeRoutes();

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );
        }

        public static void Register(HttpConfiguration config)
        {
            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );

            ODataConventionModelBuilder modelBuilder = new ODataConventionModelBuilder();
            modelBuilder.EntitySet<FontInfo>("FontInfo");
            modelBuilder.EntitySet<FontSummary>("FontSummary");
            IEdmModel model = modelBuilder.GetEdmModel();
            config.Routes.MapODataRoute(routeName: "odataFontInfo", routePrefix: "o", model: model);

            //ODataConventionModelBuilder fsBuilder = new ODataConventionModelBuilder();
            //fsBuilder.EntitySet<FontSummary>("FontSummary");
            //IEdmModel fsModel = fsBuilder.GetEdmModel();
            //config.Routes.MapODataRoute(routeName: "routeTwo", routePrefix: "o2", model: fsModel);

            // Uncomment the following line of code to enable query support for actions with an IQueryable or IQueryable<T> return type.
            // To avoid processing unexpected or malicious queries, use the validation settings on QueryableAttribute to validate incoming queries.
            // For more information, visit http://go.microsoft.com/fwlink/?LinkId=279712.
            config.EnableQuerySupport();
            config.Formatters.InsertRange(0, ODataMediaTypeFormatters.Create());

            // To disable tracing in your application, please comment out or remove the following line of code
            // For more information, refer to: http://www.asp.net/web-api
            config.EnableSystemDiagnosticsTracing();
        }

        private void RegisterRoutes(HttpConfiguration config)
        {
            config.EnableQuerySupport();

            var modelBuilder = new ODataConventionModelBuilder();
            SetEntity(modelBuilder);
            SetAction(modelBuilder);
            var model = modelBuilder.GetEdmModel();

            config.Routes.MapODataRoute(
                routeName: "OData",
                routePrefix: "odata",
                model: model);

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

            config.EnableCors(new EnableCorsAttribute("*", "*", "*", "authorization"));

            //使OData Action支持CORS
            config.Formatters.InsertRange(0, ODataMediaTypeFormatters.Create());
        }

        public HttpConfiguration Configure(HttpConfiguration config)
        {
            config.MapHttpAttributeRoutes();

            //let keep only the JSON formatter
            config.Formatters.Clear();
            config.Formatters.Add(new JsonMediaTypeFormatter());

            // Uncomment the following line of code to enable query support for actions with an IQueryable or IQueryable<T> return type.
            // To avoid processing unexpected or malicious queries, use the validation settings on QueryableAttribute to validate incoming queries.
            // For more information, visit http://go.microsoft.com/fwlink/?LinkId=301869.
            config.EnableQuerySupport(new QueryableAttribute() { MaxExpansionDepth = 5 });

            // To disable tracing in your application, please comment out or remove the following line of code
            // For more information, refer to: http://www.asp.net/web-api
            config.EnableSystemDiagnosticsTracing();

            //enable cross domain requests
            config.EnableCors(new EnableCorsAttribute("*", "*", "*"));

            //OData based rest endpoint
            config.Routes.MapODataRoute(
                "ODataRoute",
                "rest",
                new RestApiModelBuilder().GetEdmModel());

            //RPC based rpc endpoint
            config.Routes.MapHttpRoute(
                name: "RPCRoute",
                routeTemplate: "rpc/{controller}/{action}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );

            return config;
        }