C# ODataConventionModelBuilder.EntitySet方法代码示例

 private static IEdmModel GetEdmModel()
 {
     var builder = new ODataConventionModelBuilder();
     builder.EntitySet<Dominio>("Dominios");
     builder.EntitySet<Server>("Servers");
     return builder.GetEdmModel();
 }

        private IEdmModel GetEdmModel()
        {
            ODataModelBuilder builder = new ODataConventionModelBuilder();


            builder.EntitySet<Billing_Rules>("Billing_Rules");
            builder.EntitySet<ApplyAt>("ApplyAts");
            builder.EntitySet<Charge>("Charges");
            builder.EntitySet<ChargesType>("ChargesTypes");
            builder.EntitySet<BillTime>("BillTimes");
            builder.EntitySet<BoardType>("BoardTypes");
            builder.EntitySet<Country>("Countries");
            builder.EntitySet<Currency>("Currencies");
            builder.EntitySet<Document_Type>("Document_Types");
            builder.EntitySet<Language>("Languages");
            builder.EntitySet<MemberType>("MemberTypes");         
            builder.EntitySet<PaymentMode>("PaymentModes");
            builder.EntitySet<ReservationStatusType>("ReservationStatusTypes");
            builder.EntitySet<RoomStatusType>("RoomStatusTypes");
            builder.EntitySet<RateType>("RateTypes");
            builder.EntitySet<WaitingListStatus>("WaitingListStatus");

     


          return builder.GetEdmModel();
        }

        public static void Register(HttpConfiguration config)
        {
			ODataModelBuilder builder = new ODataConventionModelBuilder();
			builder.EntitySet<Product>("Products");
			builder.EntitySet<Customer>("Customers");
			builder.EntitySet<ApplicationUser>("Users");

			config.MapODataServiceRoute(
				routeName: "ODataRoute",
				routePrefix: null,
				model: builder.GetEdmModel());
			// Web API configuration and services
														  // Configure Web API to use only bearer token authentication.
			//config.SuppressDefaultHostAuthentication();
            //config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));

            // Web API routes
            config.MapHttpAttributeRoutes();

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

    // For more information on configuring authentication, please visit http://go.microsoft.com/fwlink/?LinkId=301864
    public void ConfigureWebApi(IAppBuilder app)
    {
      var config = new HttpConfiguration();

      // Web API routes
      config.MapHttpAttributeRoutes(); //NB Must come before OData route mapping
      config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}", new { id = RouteParameter.Optional });

      // OData:  Create the OData model.  Here, we're using the convention model builder that will use OData
      // convention defaults for model creation and routing.
      ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
      
      // All entity properties should be in lower camel case
      builder.EnableLowerCamelCase();

      // Because PersonSearchHit inherits from SearchHit, we'll ignore it.
      // This gets around the convention builder's decision to create an entity out of the SearchHit object.
      builder.Ignore<PersonSearchHit>();

      // Create two entity sets:
      // One for search features and one that will retrieve a given person.
      builder.EntitySet<IndexSearch>("Search");
      builder.EntitySet<Person>("People");
      
      // OData model registration and route creation
      config.MapODataServiceRoute("ODataRoute", null, builder.GetEdmModel());

      // Set up the bearer token that will be required to do OData calls.
      WebApiConfigBearerToken.Configure(config);

      app.UseWebApi(config);
    }

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

            // OData
            ODataModelBuilder builder = new ODataConventionModelBuilder();
            builder.EntitySet<Player>("Players");
            builder.EntitySet<BattingDetail>("BattingDetails");
            builder.EntitySet<BowlingDetail>("BowlingDetails");
            builder.EntitySet<Country>("Countrys");
            builder.EntitySet<Match>("Matches").EntityType.HasKey(m => m.MatchNumber);
            config.AddODataQueryFilter();
            config.MapODataServiceRoute(
                routeName: "odata",
                routePrefix: "odata",
                model: builder.GetEdmModel());
        }

        private void Application_Start(object sender, EventArgs e)
        {
            GlobalConfiguration.Configure(config => {
                // Enable OData query
                config.EnableQuerySupport();

                // Build the OData EDM
                var builder = new ODataConventionModelBuilder();
                builder.EntitySet<WebApi.OData.Controllers.Test>("test");

                // Normal entities set
                builder.EntitySet<Entity1>("Entities1");

                // Composite key
                builder.EntitySet<Entity2>("Entities2").EntityType.HasKey(e => e.Key1).HasKey(e=> e.Key2);

                // Build model
                var model = builder.GetEdmModel();

                // Add routing conventions
                var routingConventions = ODataRoutingConventions.CreateDefault();

                // Add support for casting: http://example.com/odata/Entities1/Namespace.Type
                routingConventions.Insert(0, new OData.CastRoutingConvention());

                // Add support for navigation keys: http://example.com/odata/Entities1(key)/Navigation(key)
                routingConventions.Insert(1, new OData.NavigationIndexRoutingConvention());

                // Add support for composite keys: http://example.com/odata/Entities1(Key1=..., Key2=...)
                routingConventions.Insert(2, new OData.CompositeKeyRoutingConvention());

                // Map the OData route and the batch handler route
                config.MapODataServiceRoute("ODataRoute", "odata", model, new DefaultODataPathHandler(), routingConventions, new DefaultODataBatchHandler(GlobalConfiguration.DefaultServer));
            });
        }

        private static IEdmModel GetConventionModel()
        {
            ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
            EntitySetConfiguration<ModelAliasingMetadataCustomer> customers = builder.EntitySet<ModelAliasingMetadataCustomer>("ModelAliasingQueryCustomers");
            customers.EntityType.Name = "Customer";
            customers.EntityType.Namespace = "ModelAliasing";
            customers.EntityType.ComplexProperty(c => c.BillingAddress).Name = "FinancialAddress";
            customers.EntityType.Property(c => c.Name).Name = "ClientName";
            customers.EntityType.HasMany(c => c.Orders).Name = "Purchases";
            EntitySetConfiguration<ModelAliasingMetadataOrder> orders = builder.EntitySet<ModelAliasingMetadataOrder>("Orders");
            orders.EntityType.Name = "Order";
            orders.EntityType.Namespace = "AliasedNamespace";
            EntityTypeConfiguration<ModelAliasingMetadataExpressOrder> expressOrder = builder.EntityType<ModelAliasingMetadataExpressOrder>().DerivesFrom<ModelAliasingMetadataOrder>();
            expressOrder.Name = "ExpressOrder";
            expressOrder.Namespace = "Purchasing";
            expressOrder.Property(eo => eo.ExpressFee).Name = "Fee";
            EntityTypeConfiguration<ModelAliasingMetadataFreeDeliveryOrder> freeDeliveryOrder = builder.EntityType<ModelAliasingMetadataFreeDeliveryOrder>().DerivesFrom<ModelAliasingMetadataOrder>();
            freeDeliveryOrder.Name = "FreeDeliveryOrder";
            freeDeliveryOrder.Namespace = "Purchasing";
            EntitySetConfiguration<ModelAliasingMetadataProduct> products = builder.EntitySet<ModelAliasingMetadataProduct>("Products");
            EntitySetConfiguration<ModelAliasingMetadataOrderLine> ordersLines = builder.EntitySet<ModelAliasingMetadataOrderLine>("OrdersLines");
            ordersLines.EntityType.Property(ol => ol.Price).Name = "Cost";
            ComplexTypeConfiguration<ModelAliasingMetadataRegion> region = builder.ComplexType<ModelAliasingMetadataRegion>();
            region.Name = "PoliticalRegion";
            region.Namespace = "Location";

            ComplexTypeConfiguration<ModelAliasingMetadataAddress> address = builder.ComplexType<ModelAliasingMetadataAddress>();
            address.Name = "Direction";
            address.Namespace = "Location";
            address.ComplexProperty<ModelAliasingMetadataRegion>(c => c.Country).Name = "Reign";
            return builder.GetEdmModel();
        }

        public ParameterAliasNodeTranslatorTest()
        {
            var builder = new ODataConventionModelBuilder();
            builder.EntitySet<ParameterAliasCustomer>("Customers");
            builder.EntitySet<ParameterAliasOrder>("Orders");

            builder.EntityType<ParameterAliasCustomer>().Function("CollectionFunctionCall")
                .ReturnsCollection<int>().Parameter<int>("p1");

            builder.EntityType<ParameterAliasCustomer>().Function("EntityCollectionFunctionCall")
                .ReturnsCollectionFromEntitySet<ParameterAliasCustomer>("Customers").Parameter<int>("p1");

            builder.EntityType<ParameterAliasCustomer>().Function("SingleEntityFunctionCall")
                .Returns<ParameterAliasCustomer>().Parameter<int>("p1");

            builder.EntityType<ParameterAliasCustomer>().Function("SingleEntityFunctionCallWithoutParameters")
                .Returns<ParameterAliasCustomer>();

            builder.EntityType<ParameterAliasCustomer>().Function("SingleValueFunctionCall")
                .Returns<int>().Parameter<int>("p1");

            _model = builder.GetEdmModel();
            _customersEntitySet = _model.FindDeclaredEntitySet("Customers");
            _customerEntityType = _customersEntitySet.EntityType();
            _parameterAliasMappedNode = new ConstantNode(123);
        }

        public static Microsoft.OData.Edm.IEdmModel GetModel()
        {
            var builder = new ODataConventionModelBuilder();
            builder.EntitySet<Product>("Products");
            builder.EntitySet<Supplier>("Suppliers");

            //配置一个函数
            //builder.EntitySet<Product>("Products").EntityType.Collection.Function("MostExpensive").Returns<double>(); //获取最贵产品价格的路由设置

            //配置一个Action
            //builder.EntitySet<Product>("Products").EntityType.Action("Rate").Parameter<int>("Rating");

            #region 服务的另一种配置方法
            //http://www.asp.net/web-api/overview/odata-support-in-aspnet-web-api/odata-v4/odata-actions-and-functions
            builder.Namespace = "ProductService";
            builder.EntityType<Product>().Collection
                .Function("MostExpensive")  //函数路由
                .Returns<double>();

            builder.Namespace = "ProductService";
            builder.EntityType<Product>()
                .Action("Rate")  //Action路由
                .Parameter<int>("Rating");
            #endregion

            return builder.GetEdmModel();
        }

        public static void Register(HttpConfiguration config)
        {
            config.EnableCors();

            config.MapHttpAttributeRoutes();

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

            ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
            builder.EntitySet<Exercise>("Exercises");
            builder.EntitySet<Workout>("Workouts");
            builder.EntitySet<WorkoutSession>("WorkoutSessions");
            builder.EntitySet<ExerciseSet>("ExerciseSets");
            builder.EnableLowerCamelCase();

            // Need this. Otherwise SingleResult<WorkoutSession> GetWorkoutSession tries to return null and then fails to serialize the null value.
            config.MapODataServiceRoute(
                "odata"
                , "odata"
                , builder.GetEdmModel()
                , defaultHandler: HttpClientFactory.CreatePipeline(
                    innerHandler: new HttpControllerDispatcher(config)
                    , handlers: new[] { new ODataNullValueMessageHandler() }));
        }

		public static IEdmModel GetModel()
		{
			ODataModelBuilder builder = new ODataConventionModelBuilder();
			builder.Namespace = "D";
			builder.ContainerName = "Default";

			EntitySetConfiguration<City> cities = builder.EntitySet<City>("City");
			EntitySetConfiguration<Stadium> stadiums = builder.EntitySet<Stadium>("Stadium");

			// Per Collection Stadium
			FunctionConfiguration getStadiumsWithFunction = stadiums.EntityType.Collection.Function("GetStadiumsWithFunction");
			getStadiumsWithFunction.ReturnsCollectionFromEntitySet<Stadium>("Stadium");

			//  Per Collection Stadium, returns single entity
			FunctionConfiguration getStadiumsTest = stadiums.EntityType.Collection.Function("GetStadiumTest");
			getStadiumsTest.Parameter<string>("test");
			getStadiumsTest.Parameter<string>("name");
			getStadiumsTest.ReturnsFromEntitySet<Stadium>("Stadium");

			// Per Entity (Single key property) City
			FunctionConfiguration getStadiumFromCityWithFunction = cities.EntityType.Function("GetStadiumsFromCityWithFunction");
			getStadiumFromCityWithFunction.ReturnsCollectionFromEntitySet<Stadium>("Stadium");

			// Per Entity composite key Stadium
			FunctionConfiguration getCityFromStadiumWithFunction = stadiums.EntityType.Function("GetCityFromStadiumWithFunction");
			getCityFromStadiumWithFunction.ReturnsFromEntitySet<City>("City");

			// Global Function
			builder.Function("GlobalFunction").ReturnsCollectionFromEntitySet<Stadium>("Stadium");

			
			
			return builder.GetEdmModel();
		}

 private static IEdmModel GetEdmModel()
 {
     var builder = new ODataConventionModelBuilder();
     builder.EntitySet<ResponseDataModel>("Users");
     builder.EntitySet<CustomerCardAdministrationDataModel>("CustomerCards");
     return builder.GetEdmModel();
 }

        private static IEdmModel GetModel()
        {
            const string UsersSet = "Users";
            const string FriendshipsSet = "Friendships";
            const string TweetsSet = "Tweets";

            var builder = new ODataConventionModelBuilder();
            var users = builder.EntitySet<User>(UsersSet);
            builder.EntitySet<Friendship>(FriendshipsSet);
            builder.EntitySet<Tweet>(TweetsSet);

            users.EntityType.Ignore(u => u.Password);
            users.EntityType.Ignore(u => u.Email);

            // nameof(...) == "Login"
            builder.Namespace = "TwitterApi";
            var login = users.EntityType.Collection.Action(nameof(UsersController.Login));
            login.Parameter<string>(nameof(User.Password));
            login.Parameter<string>(nameof(User.Email));
            login.Returns<AuthenticateResponse>();

            var me = users.EntityType.Collection.Function(nameof(UsersController.Me));
            me.ReturnsFromEntitySet<User>(UsersSet);

            return builder.GetEdmModel();
        }

        public void NavigationLinksGenerationConvention_GeneratesLinksWithCast_ForDerivedProperties()
        {
            ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
            builder.EntitySet<Vehicle>("vehicles");
            builder.EntitySet<Manufacturer>("manufacturers");

            IEdmModel model = builder.GetEdmModel();
            IEdmEntitySet vehiclesEdmEntitySet = model.EntityContainers().Single().FindEntitySet("vehicles");
            IEdmEntityType carType = model.AssertHasEntityType(typeof(Car));
            IEdmNavigationProperty carManufacturerProperty = carType.AssertHasNavigationProperty(model, "Manufacturer", typeof(CarManufacturer), isNullable: true, multiplicity: EdmMultiplicity.ZeroOrOne);

            HttpConfiguration configuration = new HttpConfiguration();
            configuration.EnableOData(model);

            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost");
            request.Properties[HttpPropertyKeys.HttpConfigurationKey] = configuration;
            request.Properties[HttpPropertyKeys.HttpRouteDataKey] = new HttpRouteData(new HttpRoute());

            IEntitySetLinkBuilder linkBuilder = model.GetEntitySetLinkBuilder(vehiclesEdmEntitySet);

            Uri uri = linkBuilder.BuildNavigationLink(
                new EntityInstanceContext()
                {
                    EdmModel = model,
                    EntitySet = vehiclesEdmEntitySet,
                    EntityType = carType,
                    UrlHelper = request.GetUrlHelper(),
                    PathHandler = new DefaultODataPathHandler(model),
                    EntityInstance = new Car { Model = 2009, Name = "Accord" }
                },
                carManufacturerProperty);

            Assert.Equal("http://localhost/vehicles(Model=2009,Name='Accord')/System.Web.Http.OData.Builder.TestModels.Car/Manufacturer", uri.AbsoluteUri);
        }

 public static IEdmModel GetEdmModel()
 {
     var builder = new ODataConventionModelBuilder();
     builder.EntitySet<Product>("Products");
     builder.EntitySet<Part>("Parts");
     return builder.GetEdmModel();
 }