C# HttpConfiguration.MapODataServiceRoute方法代码示例

        [InlineData("GET", "http://localhost/Customers(12)/NS.SpecialCustomer/NS.GetSalary()", "GetSalaryFromSpecialCustomer_12")] // call function on derived entity type
        public async Task AttriubteRouting_SelectsExpectedControllerAndAction(string method, string requestUri,
            string expectedResult)
        {
            // Arrange
            CustomersModelWithInheritance model = new CustomersModelWithInheritance();

            var controllers = new[] { typeof(CustomersController), typeof(MetadataAndServiceController), typeof(OrdersController) };
            TestAssemblyResolver resolver = new TestAssemblyResolver(new MockAssembly(controllers));

            HttpConfiguration config = new HttpConfiguration();
            config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
            config.Services.Replace(typeof(IAssembliesResolver), resolver);

            config.MapODataServiceRoute("odata", "", model.Model);

            HttpServer server = new HttpServer(config);
            config.EnsureInitialized();

            HttpClient client = new HttpClient(server);
            HttpRequestMessage request = new HttpRequestMessage(new HttpMethod(method), requestUri);

            // Act
            var response = await client.SendAsync(request);

            // Assert
            if (!response.IsSuccessStatusCode)
            {
                Assert.False(true, await response.Content.ReadAsStringAsync());
            }
            var result = await response.Content.ReadAsAsync<AttributeRoutingTestODataResponse>();
            Assert.Equal(expectedResult, result.Value);
        }

        public SelectExpandTest()
        {
            _configuration =
                new[]
                {
                    typeof(SelectExpandTestCustomersController), typeof(SelectExpandTestCustomersAliasController),
                    typeof(PlayersController), typeof(NonODataSelectExpandTestCustomersController),
                    typeof(AttributedSelectExpandCustomersController), typeof(SelectExpandTestCustomer),
                    typeof(SelectExpandTestSpecialCustomer), typeof(SelectExpandTestCustomerWithAlias),
                    typeof(SelectExpandTestOrder), typeof(SelectExpandTestSpecialOrder),
                    typeof(SelectExpandTestSpecialOrderWithAlias)
                }.GetHttpConfiguration();
            _configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;

            _configuration.MapODataServiceRoute("odata", "odata", GetModel());
            _configuration.MapODataServiceRoute("odata-inheritance", "odata-inheritance", GetModelWithInheritance());
            _configuration.MapODataServiceRoute("odata-alias", "odata-alias", GetModelWithCustomerAlias());
            _configuration.MapODataServiceRoute(
                "odata-alias2-inheritance",
                "odata-alias2-inheritance",
                GetModelWithCustomerAliasAndInheritance());
            _configuration.MapODataServiceRoute("odata2", "odata2", GetModelWithProcedures());
            _configuration.Routes.MapHttpRoute("api", "api/{controller}", new { controller = "NonODataSelectExpandTestCustomers" });

            HttpServer server = new HttpServer(_configuration);
            _client = new HttpClient(server);
        }

        public static void Register(HttpConfiguration config)
        {
            //
            // Web API routes
            //
            config.MapHttpAttributeRoutes();

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

            //
            // OData CRUD Routes
            //
            config.MapODataServiceRoute(
                routeName: "odata",
                routePrefix: "odata",
                model: GetModel());

            //
            // OData Read only Routes
            //
            config.MapODataServiceRoute(
                routeName: "odataReadOnly",
                routePrefix: "odata/readonly",
                model: GetReadOnlyModel());

            var appXmlType = config.Formatters.XmlFormatter.SupportedMediaTypes.FirstOrDefault(t => t.MediaType == "application/xml");
            config.Formatters.XmlFormatter.SupportedMediaTypes.Remove(appXmlType);
        }

        public static void UpdateConfiguration(HttpConfiguration configuration)
        {
            var controllers = new[] { typeof(EmployeesController), typeof(MetadataController) };
            TestAssemblyResolver resolver = new TestAssemblyResolver(new TypesInjectionAssembly(controllers));

            configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
            configuration.Services.Replace(typeof(IAssembliesResolver), resolver);

            configuration.Routes.Clear();

            IEdmModel edmModel = UnBoundFunctionEdmModel.GetEdmModel();
            DefaultODataPathHandler pathHandler = new DefaultODataPathHandler();

            // only with attribute routing & metadata routing convention
            IList<IODataRoutingConvention> routingConventions = new List<IODataRoutingConvention>
            {
                new AttributeRoutingConvention(edmModel, configuration),
                new MetadataRoutingConvention()
            };
            configuration.MapODataServiceRoute("AttributeRouting", "AttributeRouting", edmModel, pathHandler, routingConventions);

            // only with convention routing
            configuration.MapODataServiceRoute("ConventionRouting", "ConventionRouting", edmModel, pathHandler, ODataRoutingConventions.CreateDefault());
            configuration.EnsureInitialized();
        }

        public static void UpdateConfiguration(HttpConfiguration configuration)
        {
            var controllers = new[] { typeof(ForeignKeyCustomersController),
                typeof(ForeignKeyOrdersController),
                typeof(ForeignKeyCustomersNoCascadeController),
                typeof(ForeignKeyOrdersNoCascadeController),
                typeof(MetadataController) };

            TestAssemblyResolver resolver = new TestAssemblyResolver(new TypesInjectionAssembly(controllers));
            configuration.Services.Replace(typeof(IAssembliesResolver), resolver);

            configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;

            configuration.Routes.Clear();
            configuration.GetHttpServer();
            configuration.MapODataServiceRoute(routeName: "explicit", routePrefix: "explicit",
                model: ForeignKeyEdmModel.GetExplicitModel(foreignKey: true));

            configuration.MapODataServiceRoute(routeName: "convention", routePrefix: "convention",
                model: ForeignKeyEdmModel.GetConventionModel());

            configuration.MapODataServiceRoute(routeName: "noncascade", routePrefix: "noncascade",
                model: ForeignKeyEdmModel.GetExplicitModel(foreignKey: false));

            configuration.EnsureInitialized();
        }

        public static void UpdateConfiguration(HttpConfiguration configuration)
        {
            var controllers = new[] { typeof(FilesController), typeof(MetadataController) };
            TestAssemblyResolver resolver = new TestAssemblyResolver(new TypesInjectionAssembly(controllers));
            configuration.Services.Replace(typeof(IAssembliesResolver), resolver);

            configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;

            TimeZoneInfo timeZoneInfo = TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time"); // -8:00
            configuration.SetTimeZoneInfo(timeZoneInfo);

            configuration.Routes.Clear();
            HttpServer httpServer = configuration.GetHttpServer();
            configuration.MapODataServiceRoute(
                routeName: "convention",
                routePrefix: "convention",
                model: DateTimeEdmModel.GetConventionModel());

            configuration.MapODataServiceRoute(
                routeName: "explicit",
                routePrefix: "explicit",
                model: DateTimeEdmModel.GetExplicitModel(),
                batchHandler: new DefaultODataBatchHandler(httpServer));

            configuration.EnsureInitialized();
        }

        private static void ConfigureWebApiOData(HttpConfiguration config)
        {
            var controllerSelector = new ODataVersionControllerSelector(config);
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);

            // Define a versioned route
            config.MapODataServiceRoute("V1RouteVersioning", "odata/v1", GetVersionedModel());
            controllerSelector.RouteVersionSuffixMapping.Add("V1RouteVersioning", "V1");

            // Define a versioned route that doesn't map to any controller
            config.MapODataServiceRoute("odata/v2", "odata/v2", GetFakeModel());
            controllerSelector.RouteVersionSuffixMapping.Add("odata/v2", "V2");

            // Define a custom route with custom routing conventions
            var conventions = ODataRoutingConventions.CreateDefault();
            conventions.Insert(0, new CustomNavigationPropertyRoutingConvention());
            var customODataRoute = config.MapODataServiceRoute("CustomODataRoute", ODataRoutePrefix, GetCustomRouteModel(), batchHandler: null, pathHandler: new DefaultODataPathHandler(), routingConventions: conventions);
            config.AddCustomSwaggerRoute(customODataRoute, "/Customers({Id})/Orders")
                .Operation(HttpMethod.Post)
                .PathParameter<int>("Id")
                .BodyParameter<Order>("order");

            // Define a route to a controller class that contains functions
            config.MapODataServiceRoute("FunctionsODataRoute", ODataRoutePrefix, GetFunctionsEdmModel());

            // Define a default non- versioned route(default route should be at the end as a last catch-all)
            config.MapODataServiceRoute("DefaultODataRoute", ODataRoutePrefix, GetDefaultModel());
        }

 public static void UpdateConfiguration(HttpConfiguration configuration)
 {
     configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
     var model1 = GetEdmModel1(configuration);
     var model2 = GetEdmModel2(configuration);
     configuration.MapODataServiceRoute("OData1", "v1", model1, new DefaultODataPathHandler(), ODataRoutingConventions.CreateDefault());
     configuration.MapODataServiceRoute("OData2", "v2", model2, new DefaultODataPathHandler(), ODataRoutingConventions.CreateDefault());
     configuration.Routes.MapHttpRoute("ApiDefault", "api/{controller}/{action}/{id}", new { id = RouteParameter.Optional });
 }

        public static void UpdateConfiguration(HttpConfiguration configuration)
        {
            HttpServer server = configuration.Properties["Nuwa.HttpServerKey"] as HttpServer;

            configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
            configuration.MapODataServiceRoute("noPrefix", "", GetEdmModel(), new DefaultODataPathHandler(), ODataRoutingConventions.CreateDefault());
            configuration.MapODataServiceRoute("prefix", "prefix", GetEdmModel(), new DefaultODataPathHandler(), ODataRoutingConventions.CreateDefault());
            configuration.MapODataServiceRoute("oneParameterInPrefix", "{a}", GetEdmModel(), new DefaultODataPathHandler(), ODataRoutingConventions.CreateDefault());
        }

        public static void Register(HttpConfiguration config)
        {
            // Default routes
            config.MapODataServiceRoute(
                routeName: "DefaultODataRoute",
                routePrefix: null,
                model: GetModel());

            // Versioning by route prefix
            config.MapODataServiceRoute(
                routeName: "V2RouteVersioning",
                routePrefix: "versionbyroute/v2",
                model: GetModel());

            // Versioning by query string
            config.Routes.MapODataServiceRoute(
                routeName: "V2QueryStringVersioning",
                routePrefix: "versionbyquery",
                model: GetModel(),
                queryConstraints: new { v = "2" },
                headerConstraints: null);

            // Versioning by header value
            config.Routes.MapODataServiceRoute(
                routeName: "V2HeaderVersioning",
                routePrefix: "versionbyheader",
                model: GetModel(),
                queryConstraints: null,
                headerConstraints: new { v = "2" });

            var controllerSelector = config.Services.GetService(typeof(IHttpControllerSelector)) as ODataVersionControllerSelector;
            // Mapping route name to controller versioning suffix
            controllerSelector.RouteVersionSuffixMapping.Add("DefaultODataRoute", "V2");
            controllerSelector.RouteVersionSuffixMapping.Add("V2RouteVersioning", "V2");
            controllerSelector.RouteVersionSuffixMapping.Add("V2QueryStringVersioning", "V2");
            controllerSelector.RouteVersionSuffixMapping.Add("V2HeaderVersioning", "V2");

            Mapper.CreateMap<DbProduct, Product>()
                .ForMember(dest => dest.Family, opt => opt.Ignore());
            Mapper.CreateMap<Product, DbProduct>();
            Mapper.CreateMap<DbProductFamily, ProductFamily>()
                .ForMember(dest => dest.Supplier, opt => opt.Ignore())
                .ForMember(dest => dest.Products, opt => opt.Ignore());
            Mapper.CreateMap<ProductFamily, DbProductFamily>();
            Mapper.CreateMap<DbSupplier, Supplier>()
                .ForMember(dest => dest.ProductFamilies, opt => opt.Ignore());
            Mapper.CreateMap<Supplier, DbSupplier>();
            Mapper.CreateMap<DbAddress, Address>();
            Mapper.CreateMap<Address, DbAddress>();

            Mapper.AssertConfigurationIsValid();
        }

        public static void UpdateConfiguration(HttpConfiguration configuration)
        {
            var controllers = new[] { typeof(EmployeesController), typeof(MetadataController) };
            TestAssemblyResolver resolver = new TestAssemblyResolver(new TypesInjectionAssembly(controllers));

            configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
            configuration.Services.Replace(typeof(IAssembliesResolver), resolver);

            configuration.Routes.Clear();
            configuration.MapODataServiceRoute("convention", "convention", EnumsEdmModel.GetConventionModel());
            configuration.MapODataServiceRoute("explicit", "explicit", EnumsEdmModel.GetExplicitModel(), new DefaultODataPathHandler(), ODataRoutingConventions.CreateDefault());
            configuration.EnsureInitialized();
        }

        public static void UpdateConfiguration(HttpConfiguration configuration)
        {
            var controllers = new[] { typeof(UmbrellaController), typeof(MonstersIncController), typeof(MetadataController), typeof(PartnersController) };
            TestAssemblyResolver resolver = new TestAssemblyResolver(new TypesInjectionAssembly(controllers));

            configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
            configuration.Services.Replace(typeof(IAssembliesResolver), resolver);

            configuration.Routes.Clear();
            configuration.MapODataServiceRoute("ModelBuilderWithConventionRouting", "expCon", SingletonEdmModel.GetExplicitModel("Umbrella"), new DefaultODataPathHandler(), ODataRoutingConventions.CreateDefault());
            configuration.MapODataServiceRoute("ModelBuilderWithAttributeRouting", "expAttr", SingletonEdmModel.GetExplicitModel("MonstersInc"));
            configuration.MapODataServiceRoute("ConventionBuilderwithConventionRouting", "conCon", SingletonEdmModel.GetConventionModel("Umbrella"), new DefaultODataPathHandler(), ODataRoutingConventions.CreateDefault());
            configuration.MapODataServiceRoute("ConventionBuilderwithAttributeRouting", "conAttr", SingletonEdmModel.GetConventionModel("MonstersInc"));
            configuration.EnsureInitialized();
        }

        public static void RegisterOData(HttpConfiguration config)
        {
            var masterBuilder = new ODataConventionModelBuilder();
            RegisterMasterModels(masterBuilder);
            config.MapODataServiceRoute("odataMaster", "odata", masterBuilder.GetEdmModel());

            // Issue 57: The below portion causes a failure 
            // note: You can comment out this portion and Swagger will work
            var tenantBuilder = new ODataConventionModelBuilder();
            RegisterTenantModels(tenantBuilder);
            var tenantODataRoute = config.MapODataServiceRoute("odataTenant", "odata/{tenantId}", tenantBuilder.GetEdmModel());

            // maybe adding a default would help Swagger Odata...?
            //tenantODataRoute.Defaults.Add("tenantId", 1);
        }

 protected override void ConfigureController(HttpConfiguration config)
 {
     config.MapODataServiceRoute(
         routeName: "OData funcions",
         routePrefix: "functions",
         model: GetEdmModel(config));
 }

        public void AdvancedMapODataServiceRoute_ConfiguresARoute_WithAnODataRouteAndVersionConstraints()
        {
            // Arrange
            HttpRouteCollection routes = new HttpRouteCollection();
            HttpConfiguration config = new HttpConfiguration(routes);
            IEdmModel model = new EdmModel();
            string routeName = "name";
            string routePrefix = "prefix";
            var pathHandler = new DefaultODataPathHandler();
            var conventions = new List<IODataRoutingConvention>();

            // Act
            config.MapODataServiceRoute(routeName, routePrefix, model, pathHandler, conventions);

            // Assert
            IHttpRoute odataRoute = routes[routeName];
            Assert.Single(routes);
            Assert.Equal(routePrefix + "/{*odataPath}", odataRoute.RouteTemplate);
            Assert.Equal(2, odataRoute.Constraints.Count);

            var odataPathConstraint = Assert.Single(odataRoute.Constraints.Values.OfType<ODataPathRouteConstraint>());
            Assert.Same(model, odataPathConstraint.EdmModel);
            Assert.IsType<DefaultODataPathHandler>(odataPathConstraint.PathHandler);
            Assert.NotNull(odataPathConstraint.RoutingConventions);

            var odataVersionConstraint = Assert.Single(odataRoute.Constraints.Values.OfType<ODataVersionConstraint>());
            Assert.NotNull(odataVersionConstraint.Version);
            Assert.Equal(ODataVersion.V4, odataVersionConstraint.Version);
        }