C# ODataConventionModelBuilder.ComplexType方法代码示例

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

		static void AddODataSupport( ServerHost server )
		{
			var objectModelBuilder = new ODataConventionModelBuilder();

			var bornInfo = objectModelBuilder.ComplexType<BornInfoView>();
			
			bornInfo.Property( bi => bi.When );
			bornInfo.Property( bi => bi.Where );

			var person = objectModelBuilder.EntitySet<PersonView>( "PeopleView" )
				.EntityType.HasKey( p => p.Id );

			person.Property( p => p.Name );
			person.Property( p => p.Version );
			person.ComplexProperty( p => p.BornInfo );

			var address = objectModelBuilder.EntitySet<AddressView>( "AddressesView" )
				.EntityType.HasKey( a => a.AddressId );

			address.Property( a => a.Street );
			address.Property( a => a.PersonId );

			server.AddHttpConfigurationCustomization( cfg =>
			{
				cfg.MapODataServiceRoute(
						routeName: "ODataRoute",
						routePrefix: null,
						model: objectModelBuilder.GetEdmModel()
					);
			} );
		}

        public void LowerCamelCaser_RespectExplicitProperties()
        {
            // Arrange
            var builder = new ODataConventionModelBuilder();
            EntityTypeConfiguration<LowerCamelCaserEntity> entityTypeConfiguration = builder.EntitySet<LowerCamelCaserEntity>("Entities").EntityType;
            entityTypeConfiguration.Property(b => b.ID).Name = "iD";
            entityTypeConfiguration.Property(d => d.Name).Name = "Name";
            entityTypeConfiguration.EnumProperty(d => d.Color).Name = "Something";
            ComplexTypeConfiguration<LowerCamelCaserComplex> complexTypeConfiguration = builder.ComplexType<LowerCamelCaserComplex>();
            complexTypeConfiguration.CollectionProperty(c => c.Notes).Name = "MyNotes";
            builder.OnModelCreating += new LowerCamelCaser(NameResolverOptions.RespectExplicitProperties).Apply;

            // Act
            IEdmModel model = builder.GetEdmModel();

            // Assert
            IEdmEntityType lowerCamelCaserEntity = 
                Assert.Single(model.SchemaElements.OfType<IEdmEntityType>().Where(e => e.Name == "LowerCamelCaserEntity"));
            IEdmComplexType lowerCamelCaserComplex = 
                Assert.Single(model.SchemaElements.OfType<IEdmComplexType>().Where(e => e.Name == "LowerCamelCaserComplex"));
            Assert.Equal(5, lowerCamelCaserEntity.Properties().Count());
            Assert.Single(lowerCamelCaserEntity.Properties().Where(p => p.Name == "iD"));
            Assert.Single(lowerCamelCaserEntity.Properties().Where(p => p.Name == "Name"));
            Assert.Single(lowerCamelCaserEntity.Properties().Where(p => p.Name == "details"));
            Assert.Single(lowerCamelCaserEntity.Properties().Where(p => p.Name == "Something"));
            Assert.Single(lowerCamelCaserEntity.Properties().Where(p => p.Name == "complexProperty"));
            Assert.Equal(2, lowerCamelCaserComplex.Properties().Count());
            Assert.Single(lowerCamelCaserComplex.Properties().Where(p => p.Name == "price"));
            Assert.Single(lowerCamelCaserComplex.Properties().Where(p => p.Name == "MyNotes"));
        }

 public static IEdmModel GetEdmModel()
 {
     ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
     builder.EntitySet<InheritanceCustomer>("InheritanceCustomers");
     builder.ComplexType<InheritanceLocation>();
     return builder.GetEdmModel();
 }

        public static void Register(HttpConfiguration httpConfiguration)
        {
            ODataModelBuilder builder = new ODataConventionModelBuilder();
            builder.Namespace = "ODataV4TestService.Models";
            builder.EntitySet<Product>("Products");
            builder.EntitySet<SuppliedProduct>("SuppliedProducts");
            builder.EntitySet<Supplier>("Suppliers");
            builder.EntitySet<Product>("OtherProducts");

            builder.ComplexType<Description>();
            builder.EntityType<Product>()
                .Action("Rate")
                .Parameter<int>("Rating");

            builder.EntityType<Product>().Collection
                .Function("Best")
                .ReturnsCollectionFromEntitySet<Product>("Products");

            var funcConfig = builder
                .EntityType<Product>()
                .Function("RelatedProducts")
                .SetBindingParameter("product", builder.GetTypeConfigurationOrNull(typeof(Product)))
                //.AddParameter("start", new PrimitiveTypeConfiguration(builder, builder.GetTypeConfigurationOrNull(typeof(DateTimeOffset)), typeof(DateTimeOffset)).
                .ReturnsCollectionFromEntitySet<Product>("Products");

            funcConfig
                .Parameter<DateTimeOffset>("start");

            funcConfig
                .Parameter<DateTimeOffset>("end");

            //builder.Function("GetSalesTaxRate")
            //    .Returns<double>()
            //    .Parameter<int>("PostalCode");

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

            builder.EntityType<PaymentInstrument>()
                .Collection
                .Function("GetCount")
                .Returns<int>()
                .Parameter<string>("NameContains");

            var model = builder.GetEdmModel();

            var conventions = ODataRoutingConventions.CreateDefault();
            conventions.Insert(0, new AttributeRoutingConvention(model, httpConfiguration));

            var server = new BatchServer(httpConfiguration);

            httpConfiguration.MapODataServiceRoute(
                routeName: "ODataRoute",
                routePrefix: null,
                model: model,
                pathHandler: new DefaultODataPathHandler(),
                routingConventions: conventions,
                batchHandler: new DefaultODataBatchHandler(server));

            httpConfiguration.MessageHandlers.Add(new TracingMessageHandler());
        }

        public static void ConfigureSsisService(this IAppBuilder app)
        {
            Debug.Assert(app != null);

            //// build EDM model

            var builder = new ODataConventionModelBuilder()
            {
                Namespace = typeof(SsisController).Namespace,
                ContainerName = "DefaultContainer"
            };

            builder.ComplexType<JobParameter>();
            builder.ComplexType<JobStatusResult>();
            builder.EnumType<JobStatus>();
            builder.EnumType<JobParameterType>();

            {
                var function = builder.Function("GetStatus");
                function.Parameter<string>("name").OptionalParameter = false;
                function.Returns<JobStatusResult>();
            }

            {
                var action = builder.Action("Run");
                action.Parameter<string>("name").OptionalParameter = false;
                action.CollectionParameter<JobParameter>("parameters").OptionalParameter = false;
                action.Returns<string>();
            }

            {
                var action = builder.Action("Stop");
                action.Parameter<string>("name").OptionalParameter = false;
                action.Returns<string>();
            }

            var edmModel = builder.GetEdmModel();

            //// configure web API

            var config = new HttpConfiguration() { IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always };
            config.MapODataServiceRoute("SsisService", "ssisservice", edmModel);
            config.Services.Replace(typeof(IHttpControllerSelector), new ClientHttpControllerSelector(config, typeof(SsisServiceHelper)));
            config.EnsureInitialized();

            app.UseWebApi(config);
        }

        private static IEdmModel GetSampleModel()
        {
            ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
            builder.ComplexType<Person>();

            // Employee is derived from Person. Employee has a property named manager it's Employee type.
            // It's not allowed to build inheritance complex type because a recursive loop of complex types is not allowed.
            builder.Ignore<Employee>();
            return builder.GetEdmModel();
        }

 private IEdmModel GetEdmModel()
 {
     ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
     builder.ComplexType<EnumComplexWithRequiredEnum>();
     builder.ComplexType<EnumComplexWithNullableEnum>();
     return builder.GetEdmModel();
 }

 private static IEdmModel GetSampleModel()
 {
     ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
     builder.ComplexType<EnumComplex>();
     return builder.GetEdmModel();
 }

        public void ModelBuilder_CanBuild_HttpErrorAsComplextype()
        {
            ODataModelBuilder modelBuilder = new ODataConventionModelBuilder();
            modelBuilder.ComplexType<HttpError>();
            var model = modelBuilder.GetEdmModel();

            Assert.NotNull(model);
        }

        public void ReadFromStreamAsync_ForComplexType_WithNestedComplexType()
        {
            // Arrange
            const string content = "{\"value\":{" +
              "\"City\":\"UpdatedCity\"," +
              "\"Location\": {" +
                  "\"Latitude\": 30.6," +
                  "\"Longitude\": 101.313" +
                  "}," +
              "\"SubLocation\": {" + // dynamic property
                  "\"@odata.type\":\"#System.Web.OData.Formatter.Deserialization.Location\"," +
                  "\"Latitude\": 15.5," +
                  "\"Longitude\": 130.88" +
                  "}" +
            "}}";

            ODataComplexTypeDeserializer deserializer = new ODataComplexTypeDeserializer(new DefaultODataDeserializerProvider());
            ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
            builder.ComplexType<Region>();
            IEdmModel model = builder.GetEdmModel();

            ODataDeserializerContext readContext = new ODataDeserializerContext
            {
                Model = model,
                ResourceType = typeof(Delta<Region>)
            };

            // Act
            object value = deserializer.Read(GetODataMessageReader(GetODataMessage(content), model),
                typeof(Delta<Region>), readContext);

            // Assert
            Delta<Region> region = Assert.IsType<Delta<Region>>(value);
            Assert.NotNull(region);
            Assert.Equal(new[] { "City", "Location" }, region.GetChangedPropertyNames());
            Assert.Empty(region.GetUnchangedPropertyNames());

            object propertyValue;
            Assert.True(region.TryGetPropertyValue("City", out propertyValue));
            string cityValue = Assert.IsType<string>(propertyValue);
            Assert.Equal("UpdatedCity", cityValue);

            Assert.True(region.TryGetPropertyValue("Location", out propertyValue));
            Location locationValue = Assert.IsType<Location>(propertyValue);
            Assert.Equal(30.6, locationValue.Latitude);
            Assert.Equal(101.313, locationValue.Longitude);

            // dynamic property
            Assert.True(region.TryGetPropertyValue("SubLocation", out propertyValue));
            locationValue = Assert.IsType<Location>(propertyValue);
            Assert.Equal(15.5, locationValue.Latitude);
            Assert.Equal(130.88, locationValue.Longitude);
        }

        public void ReadComplexValue_CanReadNestedOpenComplexType()
        {
            // Arrange
            ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
            builder.ComplexType<SimpleOpenAddress>();
            builder.ComplexType<SimpleOpenZipCode>();

            IEdmModel model = builder.GetEdmModel();
            IEdmComplexTypeReference addressTypeReference = model.GetEdmTypeReference(typeof(SimpleOpenAddress)).AsComplex();

            var deserializerProvider = new DefaultODataDeserializerProvider();
            var deserializer = new ODataComplexTypeDeserializer(deserializerProvider);

            ODataComplexValue zipCodeComplexValue = new ODataComplexValue
            {
                Properties = new[]
                {
                    // declared property
                    new ODataProperty { Name = "Code", Value = 101 },

                    // dynamic property
                    new ODataProperty { Name = "DateTimeProperty", Value = new DateTimeOffset(new DateTime(2014, 4, 22)) }
                },
                TypeName = typeof(SimpleOpenZipCode).FullName
            };

            ODataComplexValue addressComplexValue = new ODataComplexValue
            {
                Properties = new[]
                {
                    // declared properties
                    new ODataProperty { Name = "Street", Value = "TopStreet" },
                    new ODataProperty { Name = "City", Value = "TopCity" },

                    // dynamic properties
                    new ODataProperty { Name = "DoubleProperty", Value = 1.179 },
                    new ODataProperty { Name = "ZipCodeProperty", Value = zipCodeComplexValue }
                },
                TypeName = typeof(SimpleOpenAddress).FullName
            };

            ODataDeserializerContext readContext = new ODataDeserializerContext()
            {
                Model = model
            };

            // Act
            SimpleOpenAddress address = deserializer.ReadComplexValue(addressComplexValue, addressTypeReference, readContext)
                as SimpleOpenAddress;

            // Assert
            Assert.NotNull(address);

            // Verify the declared properties
            Assert.Equal("TopStreet", address.Street);
            Assert.Equal("TopCity", address.City);

            // Verify the dynamic properties
            Assert.NotNull(address.Properties);
            Assert.Equal(2, address.Properties.Count());
            
            Assert.Equal(1.179, address.Properties["DoubleProperty"]);
            
            // nested open complex type
            SimpleOpenZipCode zipCode = Assert.IsType<SimpleOpenZipCode>(address.Properties["ZipCodeProperty"]);
            Assert.Equal(101, zipCode.Code);
            Assert.Equal(1, zipCode.Properties.Count());
            Assert.Equal(new DateTimeOffset(new DateTime(2014, 4, 22)), zipCode.Properties["DateTimeProperty"]);
        }

        public void ReadComplexValue_Throws_IfDuplicateDynamicPropertyNameFound()
        {
            // Arrange
            ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
            builder.ComplexType<SimpleOpenAddress>();
            IEdmModel model = builder.GetEdmModel();
            IEdmComplexTypeReference addressTypeReference = model.GetEdmTypeReference(typeof(SimpleOpenAddress)).AsComplex();

            var deserializerProvider = new Mock<ODataDeserializerProvider>().Object;
            var deserializer = new ODataComplexTypeDeserializer(deserializerProvider);

            ODataComplexValue complexValue = new ODataComplexValue
            {
                Properties = new[]
                {
                    // declared properties
                    new ODataProperty { Name = "Street", Value = "My Way #599" },
                    new ODataProperty { Name = "City", Value = "Redmond & Shanghai" },

                    // dynamic properties
                    new ODataProperty { Name = "GuidProperty", Value = new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA") },
                    new ODataProperty { Name = "GuidProperty", Value = new DateTimeOffset(new DateTime(1992, 1, 1)) }
                },
                TypeName = typeof(SimpleOpenAddress).FullName
            };

            ODataDeserializerContext readContext = new ODataDeserializerContext()
            {
                Model = model
            };

            // Act & Assert
            Assert.Throws<InvalidOperationException>(() =>
                deserializer.ReadComplexValue(complexValue, addressTypeReference, readContext),
                "Duplicate dynamic property name 'GuidProperty' found in open type 'System.Web.OData.SimpleOpenAddress'. " +
                "Each dynamic property name must be unique.");
        }

        private IEdmModel GetEdmModel()
        {
            ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
            builder.EntityType<Customer>().Namespace = "NS";
            builder.ComplexType<Address>().Namespace = "NS";

            FunctionConfiguration getEnum = builder.Function("GetEnum");
            getEnum.Parameter<SimpleEnum>("simpleEnum");
            getEnum.Returns<SimpleEnum>();

            FunctionConfiguration getFlagsEnum = builder.Function("GetFlagsEnum");
            getFlagsEnum.Parameter<FlagsEnum>("flagsEnum");
            getFlagsEnum.Returns<FlagsEnum>();

            FunctionConfiguration function = builder.Function("GetNullableFlagsEnum").Returns<bool>();
            function.Parameter<FlagsEnum?>("flagsEnum");

            builder.Function("GetAddress").Returns<bool>().Parameter<Address>("address");
            builder.Function("GetCustomer").Returns<bool>().Parameter<Customer>("customer");
            return builder.GetEdmModel();
        }

        public void ODataConventionModelBuilder_CreateArrayEnumTypeCollectionPropertyWithInComplexType()
        {
            // Arrange
            var builder = new ODataConventionModelBuilder();
            builder.ComplexType<ArrayEnumTypePropertyTestModel>();
            IEdmModel model = builder.GetEdmModel();
            IEdmComplexType complexType = model.SchemaElements.OfType<IEdmComplexType>().Single();

            // Act & Assert
            Assert.Equal(3, complexType.Properties().Count());
            var colors = complexType.Properties().SingleOrDefault(p => p.Name == "Colors");
            Assert.NotNull(colors);
            Assert.True(colors.Type.IsCollection());
            Assert.False(colors.Type.IsNullable);
            Assert.True(((IEdmCollectionTypeReference)colors.Type).ElementType().IsEnum());

            var nullableColors = complexType.Properties().SingleOrDefault(p => p.Name == "NullableColors");
            Assert.NotNull(nullableColors);
            Assert.True(nullableColors.Type.IsCollection());
            Assert.True(nullableColors.Type.IsNullable);
            Assert.True(((IEdmCollectionTypeReference)nullableColors.Type).ElementType().IsEnum());
        }