private static IEdmModel BuildModel(BoundedContextElement context)
        {
            var provider  = CreateProvider(MockSource(context));
            var contextId = LookupContextId(provider);

            return(BuildModel(provider, contextId));
        }
예제 #2
0
        private Assembly CreateDynamicControllersAssembly(BoundedContextElement boundedContextElement)
        {
            var assemblyModuleName = boundedContextElement.Identity.Id.Segments.LastOrDefault() + "Controllers";

            var assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName(assemblyModuleName), AssemblyBuilderAccess.Run);
            var moduleBuilder   = assemblyBuilder.DefineDynamicModule(assemblyModuleName);

            var entities = boundedContextElement.ConceptualModel.Entities.Where(x => !string.IsNullOrEmpty(x.EntitySetName));

            foreach (var entity in entities)
            {
                var entityType = _clrTypeProvider.Get(entity.Identity);
                var parentType = typeof(GenericODataController <>).MakeGenericType(entityType);

                var controllerTypeName = entity.EntitySetName + "Controller";
                var typeBuilder        = moduleBuilder.DefineType(controllerTypeName, TypeAttributes.Public | TypeAttributes.Sealed, parentType);

                AddParentConstructor(typeBuilder, parentType);
                AddEntityElementIdAnnotation(typeBuilder, entity);
                AddContainmentEntitiesMethods(typeBuilder, parentType, entity, entityType);

                typeBuilder.CreateType();
            }

            return(assemblyBuilder);
        }
예제 #3
0
        static TestModel()
        {
            BoundedContextElement context = BoundedContextElement.Config
                                            .Name("Context")
                                            .ConceptualModel(
                StructuralModelElement.Config
                .Types((EnumTypeElement)EnumTypeElement.Config.Name("EnumType").Member("Member1", 0).Member("Member2", 1))
                .Elements(
                    EntityElement.Config
                    .Name("MasterClass")
                    .HasKey("Id")
                    .Property(EntityPropertyElement.Config.Name("Id").OfType(ElementaryTypeKind.Int32))
                    .Property(EntityPropertyElement.Config.Name("Name").OfType(ElementaryTypeKind.String))
                    .Property(EntityPropertyElement.Config.Name("EnumType").OfType <EnumTypeElement>(EnumTypeElement.Config.Name("EnumType")))
                    .Relation(EntityRelationElement.Config
                              .Name("NestedClass")
                              .DirectTo(
                                  EntityElement.Config
                                  .Name("NestedClass")
                                  .HasKey("Id")
                                  .Property(EntityPropertyElement.Config.Name("Id").OfType(ElementaryTypeKind.Int32))
                                  .Property(EntityPropertyElement.Config.Name("Name").OfType(ElementaryTypeKind.String))
                                  )
                              .AsOne())
                    ));

            var provider  = CreateProvider(MockSource(context));
            var contextId = context.Identity.Id;

            var edmModelBuilder = new EdmModelBuilder(provider);

            EdmModel = edmModelBuilder.Build(contextId).AnnotateByClrTypes(ClrTypes);
        }
예제 #4
0
        protected static EdmModel BuildStoreModel(BoundedContextElement context)
        {
            var model = BuildModel(context);

            model.StoreModel.Dump(EdmxExtensions.EdmModelType.Store);

            return(model.StoreModel);
        }
        protected static EdmModel BuildConceptualModel(BoundedContextElement context)
        {
            var model = BuildModel(context);

            model.ConceptualModel.Dump(EdmxExtensions.EdmModelType.Conceptual);

            return model.ConceptualModel;
        }
        protected static EdmModel BuildStoreModel(BoundedContextElement context)
        {
            var model = BuildModel(context);

            model.StoreModel.Dump(EdmxExtensions.EdmModelType.Store);

            return model.StoreModel;
        }
 private static IReadOnlyDictionary<IMetadataElementIdentity,Type> EmitClrTypes(BoundedContextElement context)
 {
     var typeProvider = new EmitTypeProvider();
     foreach (var element in context.ConceptualModel.Entities)
     {
         typeProvider.Resolve(element);
     }
     return typeProvider.RegisteredTypes;
 }
예제 #8
0
        private IEdmModel Build(BoundedContextElement context)
        {
            if (context.ConceptualModel == null)
            {
                throw new InvalidOperationException("The conceptual model is not specified.");
            }

            return BuildModel(context.ResolveFullName(), context.ConceptualModel);
        }
예제 #9
0
        private IEdmModel Build(BoundedContextElement context)
        {
            if (context.ConceptualModel == null)
            {
                throw new InvalidOperationException("The conceptual model is not specified.");
            }

            return(BuildModel(context.ResolveFullName(), context.ConceptualModel));
        }
        protected static DbModel BuildModel(BoundedContextElement context, ITypeProvider typeProvider = null)
        {
            var builder   = CreateBuilder(CreateMetadataProvider(MockSource(context)), typeProvider);
            var contextId = context.Identity.Id;
            var model     = builder.Build(EffortProvider, contextId);

            model.Dump();

            return(model);
        }
        protected static DbModel BuildModel(BoundedContextElement context, ITypeProvider typeProvider = null)
        {
            var builder = CreateBuilder(CreateMetadataProvider(MockSource(context)), typeProvider);
            var contextId = context.Identity.Id;
            var model = builder.Build(EffortProvider, contextId);

            model.Dump();

            return model;
        }
        private DbModelBuilder SetupBuilder(BoundedContextElement context)
        {
            var builder = CreateModelBuilder(_metadataProvider);

            foreach (var entityElement in context.ConceptualModel.Entities)
            {
                ProcessEntity(builder, entityElement);
            }

            return(builder);
        }
예제 #13
0
        private static IEdmModel Build(BoundedContextElement context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            if (context.ConceptualModel == null)
            {
                throw new InvalidOperationException("The conceptual model is not specified.");
            }

            return(BuildModel(context.ResolveFullName(), context.ConceptualModel.RootEntities));
        }
예제 #14
0
        private static IEdmModel Build(BoundedContextElement context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            if (context.ConceptualModel == null)
            {
                throw new InvalidOperationException("The conceptual model is not specified.");
            }

            return BuildModel(context.ResolveFullName(), context.ConceptualModel.RootEntities);
        }
예제 #15
0
        protected static DbModel BuildModel(BoundedContextElement context)
        {
            var metadataProvider = CreateMetadataProvider(MockSource(context));
            var clrTypeProvider = new EmitClrTypeResolver(metadataProvider);
            clrTypeProvider.Build();

            var configurator = new DbModelBuilderConfigurator(metadataProvider, clrTypeProvider);

            var builder = configurator.Configure(context);
            var model = builder.Build(EffortProvider);

            model.Dump();

            return model;
        }
예제 #16
0
        protected static DbModel BuildModel(BoundedContextElement context)
        {
            var metadataProvider = CreateMetadataProvider(MockSource(context));
            var clrTypeProvider  = new EmitClrTypeResolver(metadataProvider);

            clrTypeProvider.Build();

            var configurator = new DbModelBuilderConfigurator(metadataProvider, clrTypeProvider);

            var builder = configurator.Configure(context);
            var model   = builder.Build(EffortProvider);

            model.Dump();

            return(model);
        }
        public DbModelBuilder Configure(BoundedContextElement context)
        {
            var builder = CreateModelBuilder(_metadataProvider);

            foreach (var entityElement in context.ConceptualModel.Entities)
            {
                var entityType = _clrTypeProvider.Get(entityElement.Identity);
                if (entityType == null)
                {
                    continue;
                }

                ProcessEntity(builder, entityElement, entityType);
            }

            return(builder);
        }
        private Assembly CreateDynamicControllersAssembly(BoundedContextElement boundedContextElement)
        {
            var assemblyModuleName = boundedContextElement.Identity.Id.Segments.LastOrDefault() + "Controllers";

            var assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName(assemblyModuleName), AssemblyBuilderAccess.Run);
            var moduleBuilder = assemblyBuilder.DefineDynamicModule(assemblyModuleName);

            var entities = boundedContextElement.ConceptualModel.Entities.Where(x => !string.IsNullOrEmpty(x.EntitySetName));

            foreach (var entity in entities)
            {
                var entityType = _clrTypeProvider.Get(entity.Identity);
                var parentType = typeof(GenericODataController<>).MakeGenericType(entityType);

                var controllerTypeName = entity.EntitySetName + "Controller";
                var typeBuilder = moduleBuilder.DefineType(controllerTypeName, TypeAttributes.Public | TypeAttributes.Sealed, parentType);

                AddParentConstructor(typeBuilder, parentType);
                AddEntityElementIdAnnotation(typeBuilder, entity);
                AddContainmentEntitiesMethods(typeBuilder, parentType, entity, entityType);

                typeBuilder.CreateType();
            }

            return assemblyBuilder;
        }
        private static IReadOnlyDictionary <IMetadataElementIdentity, Type> EmitClrTypes(BoundedContextElement context)
        {
            var typeProvider = new EmitTypeProvider();

            foreach (var element in context.ConceptualModel.Entities)
            {
                typeProvider.Resolve(element);
            }
            return(typeProvider.RegisteredTypes);
        }
        private static IEdmModel BuildModel(BoundedContextElement context)
        {
            var provider = CreateProvider(MockSource(context));
            var contextId = LookupContextId(provider);

            return BuildModel(provider, contextId);
        }