コード例 #1
0
        private static void RunConvention(InternalPropertyBuilder propertyBuilder)
        {
            var dependencies = CreateDependencies();
            var context      = new ConventionContext <IConventionPropertyBuilder>(
                propertyBuilder.Metadata.DeclaringEntityType.Model.ConventionDispatcher);

            new ConcurrencyCheckAttributeConvention(dependencies)
            .ProcessPropertyAdded(propertyBuilder, context);

            new DatabaseGeneratedAttributeConvention(dependencies)
            .ProcessPropertyAdded(propertyBuilder, context);

            new KeyAttributeConvention(dependencies)
            .ProcessPropertyAdded(propertyBuilder, context);

            new MaxLengthAttributeConvention(dependencies)
            .ProcessPropertyAdded(propertyBuilder, context);

            new RequiredPropertyAttributeConvention(dependencies)
            .ProcessPropertyAdded(propertyBuilder, context);

            new StringLengthAttributeConvention(dependencies)
            .ProcessPropertyAdded(propertyBuilder, context);

            new TimestampAttributeConvention(dependencies)
            .ProcessPropertyAdded(propertyBuilder, context);
        }
コード例 #2
0
        private static void RunConvention(InternalPropertyBuilder propertyBuilder)
        {
            var context = new ConventionContext <IConventionPropertyBuilder>(
                propertyBuilder.Metadata.DeclaringEntityType.Model.ConventionDispatcher);

            new ConcurrencyCheckAttributeConvention(new TestLogger <DbLoggerCategory.Model, TestLoggingDefinitions>())
            .ProcessPropertyAdded(propertyBuilder, context);

            new DatabaseGeneratedAttributeConvention(new TestLogger <DbLoggerCategory.Model, TestLoggingDefinitions>())
            .ProcessPropertyAdded(propertyBuilder, context);

            new KeyAttributeConvention(new TestLogger <DbLoggerCategory.Model, TestLoggingDefinitions>())
            .ProcessPropertyAdded(propertyBuilder, context);

            new MaxLengthAttributeConvention(new TestLogger <DbLoggerCategory.Model, TestLoggingDefinitions>())
            .ProcessPropertyAdded(propertyBuilder, context);

            new RequiredPropertyAttributeConvention(new TestLogger <DbLoggerCategory.Model, TestLoggingDefinitions>())
            .ProcessPropertyAdded(propertyBuilder, context);

            new StringLengthAttributeConvention(new TestLogger <DbLoggerCategory.Model, TestLoggingDefinitions>())
            .ProcessPropertyAdded(propertyBuilder, context);

            new TimestampAttributeConvention(new TestLogger <DbLoggerCategory.Model, TestLoggingDefinitions>())
            .ProcessPropertyAdded(propertyBuilder, context);
        }
コード例 #3
0
        private void RunConvention(InternalEntityTypeBuilder entityTypeBuilder)
        {
            var context = new ConventionContext <IConventionEntityTypeBuilder>(entityTypeBuilder.Metadata.Model.ConventionDispatcher);

            new NotMappedMemberAttributeConvention(CreateDependencies())
            .ProcessEntityTypeAdded(entityTypeBuilder, context);
        }
コード例 #4
0
        private void RunConvention(InternalEntityTypeBuilder entityTypeBuilder)
        {
            var context = new ConventionContext <IConventionEntityTypeBuilder>(entityTypeBuilder.Metadata.Model.ConventionDispatcher);

            new NotMappedMemberAttributeConvention(new TestLogger <DbLoggerCategory.Model, TestLoggingDefinitions>())
            .ProcessEntityTypeAdded(entityTypeBuilder, context);
        }
コード例 #5
0
        private void RunConvention(InternalPropertyBuilder propertyBuilder)
        {
            var context = new ConventionContext <IConventionPropertyBuilder>(
                propertyBuilder.Metadata.DeclaringEntityType.Model.ConventionDispatcher);

            CreateKeyDiscoveryConvention().ProcessPropertyAdded(propertyBuilder, context);
        }
コード例 #6
0
        private void RunConvention(InternalModelBuilder modelBuilder)
        {
            var context = new ConventionContext <IConventionModelBuilder>(modelBuilder.Metadata.ConventionDispatcher);

            new ModelCleanupConvention(new TestLogger <DbLoggerCategory.Model, TestLoggingDefinitions>())
            .ProcessModelFinalized(modelBuilder, context);
        }
コード例 #7
0
        private void RunConvention(InternalEntityTypeBuilder entityTypeBuilder)
        {
            var context = new ConventionContext <IConventionEntityTypeBuilder>(
                entityTypeBuilder.Metadata.Model.ConventionDispatcher);

            CreateKeyDiscoveryConvention().ProcessEntityTypeAdded(entityTypeBuilder, context);
        }
コード例 #8
0
        private void RunConvention(InternalModelBuilder modelBuilder)
        {
            var context = new ConventionContext <IConventionModelBuilder>(modelBuilder.Metadata.ConventionDispatcher);

            new ModelCleanupConvention(CreateDependencies())
            .ProcessModelFinalized(modelBuilder, context);
        }
コード例 #9
0
        private void RunConvention(InternalEntityTypeBuilder entityTypeBuilder)
        {
            var context = new ConventionContext <IConventionEntityTypeBuilder>(entityTypeBuilder.Metadata.Model.ConventionDispatcher);

            new BaseTypeDiscoveryConvention(CreateDependencies())
            .ProcessEntityTypeAdded(entityTypeBuilder, context);
        }
コード例 #10
0
        private static void RunConvention(InternalEntityTypeBuilder entityTypeBuilder)
        {
            var context = new ConventionContext <IConventionEntityTypeBuilder>(entityTypeBuilder.Metadata.Model.ConventionDispatcher);

            new DerivedTypeDiscoveryConvention(new TestLogger <DbLoggerCategory.Model, TestLoggingDefinitions>())
            .ProcessEntityTypeAdded(entityTypeBuilder, context);
        }
コード例 #11
0
        private void Validate(InternalEntityTypeBuilder entityTypeBuilder)
        {
            var context = new ConventionContext <IConventionModelBuilder>(
                entityTypeBuilder.Metadata.Model.ConventionDispatcher);

            new KeyAttributeConvention(new TestLogger <DbLoggerCategory.Model, TestLoggingDefinitions>())
            .ProcessModelFinalized(entityTypeBuilder.ModelBuilder, context);
        }
コード例 #12
0
        private void RunConvention(InternalPropertyBuilder propertyBuilder)
        {
            var context = new ConventionContext <IConventionPropertyBuilder>(
                propertyBuilder.Metadata.DeclaringEntityType.Model.ConventionDispatcher);

            new NonNullableReferencePropertyConvention(CreateDependencies())
            .ProcessPropertyAdded(propertyBuilder, context);
        }
        private static void RunConvention(InternalPropertyBuilder propertyBuilder)
        {
            var context = new ConventionContext <IConventionPropertyBuilder>(
                propertyBuilder.Metadata.DeclaringEntityType.Model.ConventionDispatcher);

            new NonNullableReferencePropertyConvention(new TestLogger <DbLoggerCategory.Model, TestLoggingDefinitions>())
            .ProcessPropertyAdded(propertyBuilder, context);
        }
コード例 #14
0
        private void Validate(InternalEntityTypeBuilder entityTypeBuilder)
        {
            var context = new ConventionContext <IConventionModelBuilder>(
                entityTypeBuilder.Metadata.Model.ConventionDispatcher);

            new KeyAttributeConvention(CreateDependencies())
            .ProcessModelFinalized(entityTypeBuilder.ModelBuilder, context);
        }
コード例 #15
0
        private Navigation RunConvention(InternalRelationshipBuilder relationshipBuilder, Navigation navigation)
        {
            var context = new ConventionContext <IConventionNavigation>(
                relationshipBuilder.Metadata.DeclaringEntityType.Model.ConventionDispatcher);

            CreateNotNullNavigationConvention().ProcessNavigationAdded(relationshipBuilder, navigation, context);
            return(context.ShouldStopProcessing() ? (Navigation)context.Result : navigation);
        }
コード例 #16
0
        private void RunConvention(InternalEntityTypeBuilder entityTypeBuilder, EntityType oldBaseType)
        {
            var context = new ConventionContext <IConventionEntityType>(entityTypeBuilder.Metadata.Model.ConventionDispatcher);

            new DiscriminatorConvention(CreateDependencies())
            .ProcessEntityTypeBaseTypeChanged(
                entityTypeBuilder, entityTypeBuilder.Metadata.BaseType, oldBaseType, context);
            Assert.False(context.ShouldStopProcessing());
        }
コード例 #17
0
        private EntityType RunConvention(EntityType entityType)
        {
            entityType.AddProperty(nameof(Blog.Id), typeof(int), ConfigurationSource.Explicit, ConfigurationSource.Explicit);

            var context = new ConventionContext <IConventionEntityTypeBuilder>(entityType.Model.ConventionDispatcher);

            CreateServicePropertyDiscoveryConvention().ProcessEntityTypeAdded(entityType.Builder, context);

            return(context.ShouldStopProcessing() ? (EntityType)context.Result.Metadata : entityType);
        }
コード例 #18
0
        private void RunConvention(InternalEntityTypeBuilder entityTypeBuilder, EntityType oldBaseType)
        {
            var logger  = new TestLogger <DbLoggerCategory.Model, TestRelationalLoggingDefinitions>();
            var context = new ConventionContext <IConventionEntityType>(entityTypeBuilder.Metadata.Model.ConventionDispatcher);

            new DiscriminatorConvention(logger)
            .ProcessEntityTypeBaseTypeChanged(
                entityTypeBuilder, entityTypeBuilder.Metadata.BaseType, oldBaseType, context);
            Assert.False(context.ShouldStopProcessing());
        }
コード例 #19
0
        private InternalEntityTypeBuilder CreateInternalEntityBuilder <T>()
        {
            var modelBuilder  = new InternalModelBuilder(new Model());
            var entityBuilder = modelBuilder.Entity(typeof(T), ConfigurationSource.Convention);

            var context = new ConventionContext <IConventionEntityTypeBuilder>(modelBuilder.Metadata.ConventionDispatcher);

            new PropertyDiscoveryConvention(CreateDependencies())
            .ProcessEntityTypeAdded(entityBuilder, context);

            return(entityBuilder);
        }
コード例 #20
0
        private static InternalEntityTypeBuilder CreateInternalEntityBuilder <T>()
        {
            var modelBuilder  = new InternalModelBuilder(new Model());
            var entityBuilder = modelBuilder.Entity(typeof(T), ConfigurationSource.Convention);

            var context = new ConventionContext <IConventionEntityTypeBuilder>(modelBuilder.Metadata.ConventionDispatcher);

            new PropertyDiscoveryConvention(
                TestServiceFactory.Instance.Create <InMemoryTypeMappingSource>(),
                new TestLogger <DbLoggerCategory.Model, TestLoggingDefinitions>())
            .ProcessEntityTypeAdded(entityBuilder, context);

            return(entityBuilder);
        }
 public ImmediateConventionScope([NotNull] ConventionSet conventionSet, ConventionDispatcher dispatcher)
 {
     _conventionSet = conventionSet;
     _dispatcher    = dispatcher;
     _entityTypeBuilderConventionContext   = new ConventionContext <IConventionEntityTypeBuilder>(dispatcher);
     _entityTypeConventionContext          = new ConventionContext <IConventionEntityType>(dispatcher);
     _relationshipBuilderConventionContext = new ConventionContext <IConventionRelationshipBuilder>(dispatcher);
     _foreignKeyConventionContext          = new ConventionContext <IConventionForeignKey>(dispatcher);
     _navigationConventionContext          = new ConventionContext <IConventionNavigation>(dispatcher);
     _indexBuilderConventionContext        = new ConventionContext <IConventionIndexBuilder>(dispatcher);
     _indexConventionContext           = new ConventionContext <IConventionIndex>(dispatcher);
     _keyBuilderConventionContext      = new ConventionContext <IConventionKeyBuilder>(dispatcher);
     _keyConventionContext             = new ConventionContext <IConventionKey>(dispatcher);
     _propertyBuilderConventionContext = new ConventionContext <IConventionPropertyBuilder>(dispatcher);
     _modelBuilderConventionContext    = new ConventionContext <IConventionModelBuilder>(dispatcher);
     _annotationConventionContext      = new ConventionContext <IConventionAnnotation>(dispatcher);
     _stringConventionContext          = new ConventionContext <string>(dispatcher);
     _fieldInfoConventionContext       = new ConventionContext <FieldInfo>(dispatcher);
 }