C# ODataConventionModelBuilder.Singleton方法代码示例

 private IEdmModel GetEdmModel()
 {
     ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
     builder.EntitySet<Customer>("FormatCustomers");
     builder.Singleton<Customer>("This"); // Singleton
     return builder.GetEdmModel();
 }

 private static IEdmModel GetEdmModel()
 {
     ODataModelBuilder builder = new ODataConventionModelBuilder();
     builder.Singleton<Corporation>("Oscorp");
     builder.EntitySet<Subsidiary>("OscorpSubs");
     return builder.GetEdmModel();
 }

 private static IEdmModel GetEdmModel()
 {
     ODataModelBuilder builder = new ODataConventionModelBuilder();
     builder.Singleton<Customer>("Me");
     builder.EntitySet<Order>("Orders");
     builder.EntitySet<Customer>("Customers");
     return builder.GetEdmModel();
 }

        public static IEdmModel GetConventionModel(string singletonName)
        {
            ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
            EntitySetConfiguration<Partner> partnersConfiguration = builder.EntitySet<Partner>("Partners");
            EntityTypeConfiguration<Partner> partnerConfiguration = partnersConfiguration.EntityType;
            partnerConfiguration.Collection.Action("ResetDataSource");

            SingletonConfiguration<Company> companyConfiguration = builder.Singleton<Company>(singletonName);
            companyConfiguration.EntityType.Action("ResetDataSource");
            companyConfiguration.EntityType.Function("GetPartnersCount").Returns<int>();

            builder.Namespace = typeof (Company).Namespace;

            return builder.GetEdmModel();
        }

        public static IEdmModel GetConventionModel()
        {
            ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
            var paymentInstrumentType = builder.EntityType<PaymentInstrument>();

            builder.EntitySet<Account>("Accounts");

            builder.Singleton<Account>("AnonymousAccount");

            AddBoundActionsAndFunctions(builder);

            builder.Namespace = typeof(Account).Namespace;

            return builder.GetEdmModel();
        }

        public static IEdmModel GetEdmModel()
        {
            ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
            EntitySetConfiguration<Employee> employeesConfiguration = builder.EntitySet<Employee>("Employees");
            EntityTypeConfiguration<Employee> employeeConfiguration = employeesConfiguration.EntityType;
            employeeConfiguration.Collection.Action("ResetDataSource");

            SingletonConfiguration<Company> companyConfiguration = builder.Singleton<Company>("Umbrella");
            companyConfiguration.EntityType.Action("ResetDataSource");
            companyConfiguration.EntityType.Function("GetEmployeesCount").Returns<int>();

            builder.Namespace = typeof(Company).Namespace;

            return builder.GetEdmModel();
        }

        public void ODataMetadataSerializer_Works_ForSingleton()
        {
            // Arrange
            ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
            builder.Singleton<Customer>("Me");
            builder.EntitySet<Order>("MyOrders");
            IEdmModel model = builder.GetEdmModel();

            ODataMetadataSerializer serializer = new ODataMetadataSerializer();
            MemoryStream stream = new MemoryStream();
            IODataResponseMessage message = new ODataMessageWrapper(stream);
            ODataMessageWriterSettings settings = new ODataMessageWriterSettings();

            // Act
            serializer.WriteObject(model, typeof(IEdmModel), new ODataMessageWriter(message, settings, model), new ODataSerializerContext());

            // Assert
            stream.Seek(0, SeekOrigin.Begin);
            string result = new StreamReader(stream).ReadToEnd();
            Assert.Contains("<Singleton Name=\"Me\" Type=\"System.Web.OData.Formatter.Serialization.Models.Customer\">", result);
        }

        public void SelfLinksGenerationConvention_Uses_WithCast_IfDerivedTypeHasNavigationProperty_ForSingleton()
        {
            // Arrange
            ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
            var myVehicle = builder.Singleton<Vehicle>("MyVehicle");

            IEdmModel model = builder.GetEdmModel();
            IEdmSingleton vehicleEdmSingleton = model.EntityContainer.FindSingleton("MyVehicle");
            IEdmEntityType carType = model.AssertHasEntityType(typeof(Car));

            HttpRequestMessage request = GetODataRequest(model);
            NavigationSourceLinkBuilderAnnotation linkBuilder = model.GetNavigationSourceLinkBuilder(vehicleEdmSingleton);
            var serializerContext = new ODataSerializerContext { Model = model, NavigationSource = vehicleEdmSingleton, Url = request.GetUrlHelper() };
            var entityContext = new EntityInstanceContext(serializerContext, carType.AsReference(), new Car { Model = 2014, Name = "Contoso" });

            // Act
            EntitySelfLinks selfLinks = linkBuilder.BuildEntitySelfLinks(entityContext, ODataMetadataLevel.Default);

            // Assert
            Assert.Equal("http://localhost/MyVehicle/System.Web.OData.Builder.TestModels.Car", selfLinks.IdLink);
        }

        public void SelfLinksGenerationConvention_Uses_WithoutCast_IfDerivedTypeDoesnotHaveNavigationProperty_ForSingleton()
        {
            // Arrange
            ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
            var myMotorcycle = builder.Singleton<Motorcycle>("MyMotor");

            IEdmModel model = builder.GetEdmModel();
            IEdmSingleton vehicleEdmSingleton = model.EntityContainer.FindSingleton("MyMotor");
            IEdmEntityType sportbikeType = model.AssertHasEntityType(typeof(SportBike));

            HttpRequestMessage request = GetODataRequest(model);
            NavigationSourceLinkBuilderAnnotation linkBuilder = model.GetNavigationSourceLinkBuilder(vehicleEdmSingleton);
            var serializerContext = new ODataSerializerContext { Model = model, NavigationSource = vehicleEdmSingleton, Url = request.GetUrlHelper() };
            var entityContext = new EntityInstanceContext(serializerContext, sportbikeType.AsReference(), new SportBike { Model = 2014, Name = "Ninja" });

            // Act
            EntitySelfLinks selfLinks = linkBuilder.BuildEntitySelfLinks(entityContext, ODataMetadataLevel.Default);

            // Assert
            Assert.Equal("http://localhost/MyMotor", selfLinks.IdLink);
        }

        private static IEdmModel GetEdmModel()
        {
            ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
            builder.Namespace = "ODataSamples.WebApiService.Models";
            builder.ContainerName = "DefaultContainer";

            builder.EntitySet<Person>("People");
            builder.EntitySet<Airport>("Airports");
            builder.EntitySet<Airline>("Airlines");
            builder.Singleton<Person>("Me");

            // Customer - Order scenarios
            builder.EntitySet<Customer>("Customers");
            builder.EntitySet<Order>("Orders");

            #region Unbound Function & Action

            builder.Action("ResetDataSource");

            //TODO : Double type has some issue.
            var GetNearestAirportFun = builder.Function("GetNearestAirport");
            GetNearestAirportFun.Parameter<double>("lat");
            GetNearestAirportFun.Parameter<double>("lon");
            GetNearestAirportFun.ReturnsFromEntitySet<Airport>("Airports");

            #endregion


            #region Person Function & Action

            var personType = builder.EntityType<Person>();
            personType.Function("GetFavoriteAirline")
                .ReturnsFromEntitySet<Airline>("Airlines");

            //TODO: Fix this issue, the return type can't be "Trip".
            personType.Function("GetFriendsTrips")
                .ReturnsCollectionFromEntitySet<Airline>("Airlines")
                .Parameter<string>("userName");

            var shareTripAction = personType.Action("ShareTrip");
            shareTripAction.Parameter<string>("userName");
            shareTripAction.Parameter<int>("tripId");

            #endregion


            #region Trip Function & Action
            // TODO: The request will fail, should fix this issue.
            // GET odata/People('russellwhyte')/Trips(1001)/ODataSamples.WebApiService.Models.GetInvolvedPeople()
            var tripType = builder.EntityType<Trip>();
            tripType.Function("GetInvolvedPeople")
                .ReturnsCollectionFromEntitySet<Person>("People");

            #endregion


            #region Add Navigation Target

            var edmModel = builder.GetEdmModel();
            var peopleEntitySet = edmModel.EntityContainer.FindEntitySet("People") as EdmEntitySet;
            var meSingleton = edmModel.EntityContainer.FindSingleton("Me") as EdmSingleton;
            var flightEntityType = edmModel.FindDeclaredType("ODataSamples.WebApiService.Models.Flight") as EdmEntityType;

            var propertyAriline = flightEntityType.FindProperty("Airline") as EdmNavigationProperty;
            var propertyFrom = flightEntityType.FindProperty("From") as EdmNavigationProperty;
            var propertyTo = flightEntityType.FindProperty("To") as EdmNavigationProperty;

            var targetAirlines = edmModel.EntityContainer.FindEntitySet("Airlines");
            var targetAirports = edmModel.EntityContainer.FindEntitySet("Airports");

            peopleEntitySet.AddNavigationTarget(propertyAriline, targetAirlines);
            peopleEntitySet.AddNavigationTarget(propertyFrom, targetAirports);
            peopleEntitySet.AddNavigationTarget(propertyTo, targetAirports);

            meSingleton.AddNavigationTarget(propertyAriline, targetAirlines);
            meSingleton.AddNavigationTarget(propertyFrom, targetAirports);
            meSingleton.AddNavigationTarget(propertyTo, targetAirports);

            #endregion

            return edmModel;
        }

 private IEdmModel GetEdmModel()
 {
     ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
     builder.Singleton<EmployeeModel>("Boss");
     return builder.GetEdmModel();
 }

        public void NavigationLinksGenerationConvention_GeneratesLinksWithoutCast_ForDeclaredProperties_OnSingleton()
        {
            ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
            builder.Singleton<Car>("Contoso");
            builder.EntitySet<Manufacturer>("manufacturers");

            IEdmModel model = builder.GetEdmModel();
            IEdmSingleton vehicleEdmSingleton = model.EntityContainer.FindSingleton("Contoso");
            IEdmEntityType carType = model.AssertHasEntityType(typeof(Car));
            IEdmNavigationProperty carManufacturerProperty = carType.AssertHasNavigationProperty(model, "Manufacturer", typeof(CarManufacturer), isNullable: true, multiplicity: EdmMultiplicity.ZeroOrOne);

            HttpConfiguration configuration = new HttpConfiguration();
            string routeName = "Route";
            configuration.Routes.MapODataServiceRoute(routeName, null, model);

            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost");
            request.SetConfiguration(configuration);
            request.ODataProperties().RouteName = routeName;

            NavigationSourceLinkBuilderAnnotation linkBuilder = model.GetNavigationSourceLinkBuilder(vehicleEdmSingleton);

            var serializerContext = new ODataSerializerContext { Model = model, NavigationSource = vehicleEdmSingleton, Url = request.GetUrlHelper() };
            var entityContext = new EntityInstanceContext(serializerContext, carType.AsReference(), new Car { Model = 2014, Name = "Contoso2014" });

            Uri uri = linkBuilder.BuildNavigationLink(entityContext, carManufacturerProperty, ODataMetadataLevel.Default);

            Assert.Equal("http://localhost/Contoso/Manufacturer", uri.AbsoluteUri);
        }

        public void ModelBuilder_Products()
        {
            var modelBuilder = new ODataConventionModelBuilder();
            modelBuilder.EntitySet<Product>("Products");
            modelBuilder.Singleton<Product>("Book"); // singleton

            var model = modelBuilder.GetEdmModel();
            Assert.Equal(model.SchemaElements.OfType<IEdmSchemaType>().Count(), 3);

            var product = model.AssertHasEntitySet(entitySetName: "Products", mappedEntityClrType: typeof(Product));
            Assert.Equal(4, product.StructuralProperties().Count());
            Assert.Equal(1, product.NavigationProperties().Count());
            product.AssertHasKey(model, "ID", EdmPrimitiveTypeKind.Int32);
            product.AssertHasPrimitiveProperty(model, "ID", EdmPrimitiveTypeKind.Int32, isNullable: false);
            product.AssertHasPrimitiveProperty(model, "Name", EdmPrimitiveTypeKind.String, isNullable: true);
            product.AssertHasPrimitiveProperty(model, "ReleaseDate", EdmPrimitiveTypeKind.DateTimeOffset, isNullable: true);
            product.AssertHasComplexProperty(model, "Version", typeof(ProductVersion), isNullable: true);
            product.AssertHasNavigationProperty(model, "Category", typeof(Category), isNullable: true, multiplicity: EdmMultiplicity.ZeroOrOne);

            var singletonProduct = model.AssertHasSingleton(singletonName: "Book", mappedEntityClrType: typeof(Product));
            Assert.Same(singletonProduct, product);

            var category = model.AssertHasEntityType(mappedEntityClrType: typeof(Category));
            Assert.Equal(2, category.StructuralProperties().Count());
            Assert.Equal(1, category.NavigationProperties().Count());
            category.AssertHasKey(model, "ID", EdmPrimitiveTypeKind.String);
            category.AssertHasPrimitiveProperty(model, "ID", EdmPrimitiveTypeKind.String, isNullable: false);
            category.AssertHasPrimitiveProperty(model, "Name", EdmPrimitiveTypeKind.String, isNullable: true);
            category.AssertHasNavigationProperty(model, "Products", typeof(Product), isNullable: false, multiplicity: EdmMultiplicity.Many);

            var version = model.AssertHasComplexType(typeof(ProductVersion));
            Assert.Equal(2, version.StructuralProperties().Count());
            version.AssertHasPrimitiveProperty(model, "Major", EdmPrimitiveTypeKind.Int32, isNullable: false);
            version.AssertHasPrimitiveProperty(model, "Minor", EdmPrimitiveTypeKind.Int32, isNullable: false);
        }

        private static IEdmModel SetupModel()
        {
            ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
            // Different types of navigation sources and navigation properties.
            builder.EntitySet<ETagCustomer>("Customers");
            builder.EntitySet<ETagOrder>("Orders");
            builder.EntityType<ETagSpecialOrder>().DerivesFrom<ETagOrder>();
            builder.Singleton<ETagOrder>("BestOrder");
            builder.EntitySet<ETagAddress>("Addresses");

            // Entity without ETag to test that we only write entities with ETag.
            builder.EntitySet<NonEtagEntity>("NonEtagEntity");

            // Just a simplification for referencing the types in cast segments.
            foreach (var type in builder.StructuralTypes)
            {
                type.Namespace = "Test";
            }

            IEdmModel model = builder.GetEdmModel();
            return model;
        }

        public void SelectAction_ReturnsNull_IfPostToNavigationPropertyBindingToNonCollectionValuedNavigationProperty(string path)
        {
            // Arrange
            ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
            builder.EntitySet<Company>("Companies");
            builder.Singleton<Company>("MyCompany");
            builder.EntitySet<Employee>("Employees");
            builder.Singleton<Employee>("Tony");
            IEdmModel model = builder.GetEdmModel();

            ODataPath odataPath = new DefaultODataPathHandler().Parse(model, "http://any/", path);
            HttpControllerContext controllerContext = CreateControllerContext("Post");
            var actionMap = GetMockActionMap();

            // Act
            string selectedAction = new NavigationRoutingConvention().SelectAction(odataPath, controllerContext, actionMap);

            // Assert
            Assert.Null(selectedAction);
        }