C# ODataConventionModelBuilder.Action方法代码示例

        public static IEdmModel GetConventionModel()
        {
            ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
            EntitySetConfiguration<Employee> employees = builder.EntitySet<Employee>("Employees");
            EntityTypeConfiguration<Employee> employee = employees.EntityType;
            employee.EnumProperty<Gender>(e => e.Sex).Name = "Gender";

            employee.Collection.Function("GetEarliestTwoEmployees").ReturnsCollectionFromEntitySet<Employee>("Employees");

            var functionConfiguration = builder.Function("GetAddress");
            functionConfiguration.Parameter<int>("id");
            functionConfiguration.Returns<Address>();

            var actionConfiguration = builder.Action("SetAddress");
            actionConfiguration.Parameter<int>("id");
            actionConfiguration.Parameter<Address>("address");
            actionConfiguration.ReturnsFromEntitySet(employees);

            var resetDataSource = builder.Action("ResetDataSource");

            builder.Namespace = typeof(Employee).Namespace;
            builder.EnableLowerCamelCase();
            var edmModel = builder.GetEdmModel();
            return edmModel;
        }

        private static IEdmModel GetEdmModel(HttpConfiguration config)
        {
            var modelBuilder = new ODataConventionModelBuilder(config);
            var moviesEntitySet = modelBuilder.EntitySet<Movie>("Movies");

            // Now add actions.

            // CheckOut
            // URI: ~/odata/Movies(1)/ODataActionsSample.Models.CheckOut
            ActionConfiguration checkOutAction = modelBuilder.EntityType<Movie>().Action("CheckOut");
            checkOutAction.ReturnsFromEntitySet<Movie>("Movies");

            // ReturnMovie
            // URI: ~/odata/Movies(1)/ODataActionsSample.Models.Return
            // Binds to a single entity; no parameters.
            ActionConfiguration returnAction = modelBuilder.EntityType<Movie>().Action("Return");
            returnAction.ReturnsFromEntitySet<Movie>("Movies");

            // CheckOutMany action
            // URI: ~/odata/Movies/ODataActionsSample.Models.CheckOutMany
            // Binds to a collection of entities.  This action accepts a collection of parameters.
            ActionConfiguration checkOutManyAction = modelBuilder.EntityType<Movie>().Collection.Action("CheckOutMany");
            checkOutManyAction.CollectionParameter<int>("MovieIDs");
            checkOutManyAction.ReturnsCollectionFromEntitySet<Movie>("Movies");

            // CreateMovie action
            // URI: ~/odata/CreateMovie
            // Unbound action. It is invoked from the service root.
            ActionConfiguration createMovieAction = modelBuilder.Action("CreateMovie");
            createMovieAction.Parameter<string>("Title");
            createMovieAction.ReturnsFromEntitySet<Movie>("Movies");

            modelBuilder.Namespace = typeof(Movie).Namespace;
            return modelBuilder.GetEdmModel();
        }

        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 GetEdmModel()
 {
     var builder = new ODataConventionModelBuilder();
     builder.EntitySet<Customer>("Customers");
     builder.EntitySet<Order>("Orders");
     builder.Function("UnboundFunction").Returns<string>().Parameter<int>("param");
     builder.Action("UnboundAction").Parameter<double>("param");
     builder.EntityType<Customer>().Function("BoundFunction").Returns<double>().Parameter<string>("name");
     return builder.GetEdmModel();
 }

 public ODataSwaggerConverterTest()
 {
     var builder = new ODataConventionModelBuilder();
     builder.EntitySet<Customer>("Customers");
     builder.EntitySet<Order>("Orders");
     builder.Function("UnboundFunction").Returns<string>().Parameter<int>("param");
     builder.Action("UnboundAction").Parameter<double>("param");
     builder.EntityType<Customer>().Function("BoundFunction").Returns<double>().Parameter<string>("name");
     _model = builder.GetEdmModel();
 }

 static StoreModel()
 {
     var builder = new ODataConventionModelBuilder();
     builder.Namespace = "Microsoft.Restier.WebApi.Test";
     builder.EntitySet<Product>("Products");
     builder.Function("GetBestProduct").ReturnsFromEntitySet<Product>("Products");
     builder.Action("RemoveWorstProduct").ReturnsFromEntitySet<Product>("Products");
     Model = (EdmModel)builder.GetEdmModel();
     Product = (IEdmEntityType)Model.FindType("Microsoft.Restier.WebApi.Test.Product");
 }

 private static IEdmModel GetEdmModel()
 {
     var builder = new ODataConventionModelBuilder();
     builder.EntitySet<Customer>("Customers");
     builder.EntitySet<Order>("Orders");
     builder.Function("UnboundFunction").Returns<string>().Parameter<int>("param");
     builder.Action("UnboundAction").Parameter<double>("param");
     builder.EntityType<Customer>().Function("BoundFunction").Returns<double>().Parameter<string>("name");
     builder.EntitySet<CompositeKeyItem>("CompositeKeyItems");
     builder.EntityType<CompositeKeyItem>().HasKey(x => new { x.FirstKey, x.SecondKey });
     return builder.GetEdmModel();
 }

        public static IEdmModel GetModel()
        {
            ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
            EntitySetConfiguration<Employee> employees = builder.EntitySet<Employee>("Employees");
            EntityTypeConfiguration<Employee> employee = employees.EntityType;
            employee.EnumProperty<Gender>(e => e.Sex).Name = "Gender";

            var resetDataSource = builder.Action("ResetDataSource");

            builder.Namespace = typeof(Employee).Namespace;

            // All the property names in the generated Edm Model will become camel case if EnableLowerCamelCase() is called.
            builder.EnableLowerCamelCase();
            var edmModel = builder.GetEdmModel();
            return edmModel;
        }

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

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

            var functionConfiguration = paymentInstrumentType.Collection.Function("GetCount");
            functionConfiguration.Parameter<string>("NameContains");
            functionConfiguration.Returns<int>();

            builder.Action("ResetDataSource");

            builder.Namespace = typeof(Account).Namespace;

            return builder.GetEdmModel();
        }

        private static IEdmModel GetEdmModel(HttpConfiguration configuration)
        {
            var builder = new ODataConventionModelBuilder(configuration);

            EntitySetConfiguration<SelectCustomer> customers = builder.EntitySet<SelectCustomer>("SelectCustomer");
            customers.EntityType.Action("CreditRating").Returns<double>();
            customers.EntityType.Collection.Action("PremiumCustomers").ReturnsCollectionFromEntitySet<SelectCustomer>("SelectCustomer");

            builder.EntitySet<EFSelectCustomer>("EFSelectCustomers");
            builder.EntitySet<EFSelectOrder>("EFSelectOrders");
            builder.EntitySet<SelectOrderDetail>("SelectOrderDetail");
            builder.EntityType<SelectPremiumCustomer>();
            builder.EntitySet<SelectOrder>("SelectOrder");
            builder.EntitySet<SelectBonus>("SelectBonus");
            builder.Action("ResetDataSource");

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

        public void Apply_SetsActionLinkBuilder_OnlyIfActionIsBindable()
        {
            // Arrange
            ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
            var vehicles = builder.EntitySet<Vehicle>("vehicles");
            var paintAction = builder.Action("Paint");
            ActionLinkGenerationConvention convention = new ActionLinkGenerationConvention();

            // Act
            convention.Apply(paintAction, builder);

            // Assert
            IEdmModel model = builder.GetEdmModel();
            var paintEdmAction = model.EntityContainer.Elements.OfType<IEdmActionImport>().Single();

            ActionLinkBuilder actionLinkBuilder = model.GetAnnotationValue<ActionLinkBuilder>(paintEdmAction);

            Assert.Null(actionLinkBuilder);
        }

        public static IEdmModel GetEdmModel()
        {
            ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
            EntitySetConfiguration<Employee> entitySetConfiguration = builder.EntitySet<Employee>("Employees");
            EntityTypeConfiguration<Manager> entityTypeConfigurationOfManager = builder.EntityType<Manager>();
            EntityTypeConfiguration<Employee> entityTypeConfigurationOfEmployee = builder.EntityType<Employee>();

            #region functions

            // Function bound to a collection of base EntityType.
            entityTypeConfigurationOfEmployee.Collection.Function("GetCount")
                .Returns<int>();

            // Overload
            entityTypeConfigurationOfEmployee.Collection.Function("GetCount")
                .Returns<int>()
                .Parameter<string>("Name");

            // Function bound to a collection of derived EntityType.
            entityTypeConfigurationOfManager.Collection.Function("GetCount")
                .Returns<int>();

            // Function bound to an base EntityType
            entityTypeConfigurationOfEmployee.Function("GetEmailsCount")
                .Returns<int>();

            entityTypeConfigurationOfEmployee.Function("GetOptionalAddresses")
                .ReturnsCollection<Address>()
                .IsComposable = true;

            entityTypeConfigurationOfEmployee.Function("GetEmails")
                .ReturnsCollection<string>()
                .IsComposable = false;

            // Function bound to a derived EntityType
            entityTypeConfigurationOfManager.Function("GetEmailsCount")
                .Returns<int>();

            // Function with primitive and collection of primitive parameters
            var function = entityTypeConfigurationOfEmployee.Collection.Function("PrimitiveFunction").Returns<string>();
            function.Parameter<int>("param");
            function.Parameter<double?>("price"); // nullable
            function.Parameter<string>("name"); // nullable
            function.CollectionParameter<string>("names"); // collection with nullable element

            // Function with Enum and collection of Enum parameters
            function = entityTypeConfigurationOfEmployee.Collection.Function("EnumFunction").Returns<string>();
            function.Parameter<Color>("bkColor");
            function.Parameter<Color?>("frColor"); // nullable
            function.CollectionParameter<Color>("colors"); // collection with non-nullable element

            // Function with complex and collection of complex parameters
            function = entityTypeConfigurationOfEmployee.Collection.Function("ComplexFunction").ReturnsCollection<Address>();
            function.Parameter<Address>("address").OptionalParameter = false;
            function.Parameter<Address>("location"); // nullable
            function.CollectionParameter<Address>("addresses"); // collection with nullable element

            // Function with entity and collection of entity parameters
            function = entityTypeConfigurationOfEmployee.Collection.Function("EntityFunction").Returns<string>();
            function.EntityParameter<Employee>("person").OptionalParameter = false;
            function.EntityParameter<Employee>("guard"); // nullable
            function.CollectionEntityParameter<Employee>("staff"); // collection with nullable element

            #endregion

            #region actions

            // Action bound to a collection of base EntityType
            entityTypeConfigurationOfEmployee.Collection.Action("IncreaseSalary")
                .ReturnsCollectionFromEntitySet(entitySetConfiguration)
                .Parameter<string>("Name");

            // Action bound to a collection of derived EntityType
            entityTypeConfigurationOfManager.Collection.Action("IncreaseSalary")
                .ReturnsCollectionFromEntitySet(entitySetConfiguration)
                .Parameter<string>("Name");

            // Action bound to a base EntityType
            entityTypeConfigurationOfEmployee.Action("IncreaseSalary")
                .Returns<int>();

            // Action bound to a derived EntityType
            entityTypeConfigurationOfManager.Action("IncreaseSalary")
                .Returns<int>();

            // Action with primitive and collection of primitive parameters
            var action = entityTypeConfigurationOfEmployee.Collection.Action("PrimitiveAction");
            action.Parameter<int>("param");
            action.Parameter<double?>("price"); // nullable
            action.Parameter<string>("name"); // nullable
            action.CollectionParameter<string>("names"); // collection with nullable element

            // Action with Enum and collection of Enum parameters
            action = entityTypeConfigurationOfEmployee.Collection.Action("EnumAction");
            action.Parameter<Color>("bkColor");
            action.Parameter<Color?>("frColor"); // nullable
            action.CollectionParameter<Color>("colors"); // collection with non-nullable element

            // Action with complex and collection of complex parameters
            action = entityTypeConfigurationOfEmployee.Collection.Action("ComplexAction");
//.........这里部分代码省略.........

        public void UnboundAction_ForEnumTypeInODataConventionModelBuilder()
        {
            // Arrange
            ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
            ActionConfiguration actionConfiguration = builder.Action("UnboundAction");
            actionConfiguration.CollectionParameter<Color>("Colors");
            actionConfiguration.Returns<Color?>();

            // Act & Assert
            IEdmModel model = builder.GetEdmModel();
            IEdmActionImport actionImport = model.EntityContainer.OperationImports().Single(o => o.Name == "UnboundAction") as IEdmActionImport;

            IEdmTypeReference colors = actionImport.Action.Parameters.Single(p => p.Name == "Colors").Type;
            IEdmTypeReference returnType = actionImport.Action.ReturnType;
            IEdmEnumType colorType = model.SchemaElements.OfType<IEdmEnumType>().Single(e => e.Name == "Color");

            Assert.True(colors.IsCollection());
            Assert.False(colors.AsCollection().ElementType().IsNullable);
            Assert.Same(colorType, colors.AsCollection().ElementType().Definition);
            Assert.True(returnType.IsNullable);
            Assert.Same(colorType, returnType.Definition);
        }

        public void UnboundAction_ForEnumWithShortUnderlyingTypeInODataConventionModelBuilder()
        {
            // Arrange
            ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
            ActionConfiguration actionConfiguration = builder.Action("UnboundAction");
            actionConfiguration.Returns<ShortEnum>();

            // Act & Assert
            IEdmModel model = builder.GetEdmModel();
            IEdmAction action = model.FindDeclaredOperations("Default.UnboundAction").Single() as IEdmAction;

            IEdmTypeReference returnType = action.ReturnType;
            IEdmEnumType shortEnumType = model.SchemaElements.OfType<IEdmEnumType>().Single(e => e.Name == "ShortEnum");

            Assert.Same(shortEnumType, returnType.Definition);
            Assert.Equal(EdmPrimitiveTypeKind.Int16, returnType.AsEnum().EnumDefinition().UnderlyingType.PrimitiveKind);
        }

        private static IEdmModel GetModel()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Services.Replace(typeof(IAssembliesResolver), new TestAssemblyResolver(typeof(Customer)));
            ODataModelBuilder builder = new ODataConventionModelBuilder(config);
            builder.ContainerName = "C";
            builder.Namespace = "A.B";
            EntityTypeConfiguration<Customer> customer = builder.EntitySet<Customer>("Customers").EntityType;

            // bound actions
            ActionConfiguration primitive = customer.Action("Primitive");
            primitive.Parameter<int>("Quantity");
            primitive.Parameter<string>("ProductCode");

            ActionConfiguration complex = customer.Action("Complex");
            complex.Parameter<int>("Quantity");
            complex.Parameter<MyAddress>("Address");

            ActionConfiguration primitiveCollection = customer.Action("PrimitiveCollection");
            primitiveCollection.Parameter<string>("Name");
            primitiveCollection.CollectionParameter<int>("Ratings");

            ActionConfiguration complexCollection = customer.Action("ComplexCollection");
            complexCollection.Parameter<string>("Name");
            complexCollection.CollectionParameter<MyAddress>("Addresses");

            // unbound actions
            ActionConfiguration unboundPrimitive = builder.Action("UnboundPrimitive");
            unboundPrimitive.Parameter<int>("Quantity");
            unboundPrimitive.Parameter<string>("ProductCode");

            ActionConfiguration unboundComplex = builder.Action("UnboundComplex");
            unboundComplex.Parameter<int>("Quantity");
            unboundComplex.Parameter<MyAddress>("Address");

            ActionConfiguration unboundPrimitiveCollection = builder.Action("UnboundPrimitiveCollection");
            unboundPrimitiveCollection.Parameter<string>("Name");
            unboundPrimitiveCollection.CollectionParameter<int>("Ratings");

            ActionConfiguration unboundComplexCollection = builder.Action("UnboundComplexCollection");
            unboundComplexCollection.Parameter<string>("Name");
            unboundComplexCollection.CollectionParameter<MyAddress>("Addresses");

            return builder.GetEdmModel();
        }