public void Map_should_create_association_sets_for_associations() { var modelConfiguration = new ModelConfiguration(); var model = new EdmModel().Initialize(); var entityType = new EntityType { Name = "Source" }; model.AddEntitySet("Source", entityType); var mappingContext = new MappingContext(modelConfiguration, new ConventionsConfiguration(), model); new NavigationPropertyMapper(new TypeMapper(mappingContext)) .Map( new MockPropertyInfo(new MockType("Target"), "Nav"), entityType, () => new EntityTypeConfiguration(typeof(object))); Assert.Equal(1, model.Containers.Single().AssociationSets.Count); var associationSet = model.Containers.Single().AssociationSets.Single(); Assert.NotNull(associationSet); Assert.NotNull(associationSet.ElementType); Assert.Equal("Source_Nav", associationSet.Name); }
protected override void ApplyCore( Type memberInfo, Func <ComplexTypeConfiguration> configuration, System.Data.Entity.ModelConfiguration.Configuration.ModelConfiguration modelConfiguration) { this._entityConfigurationAction(new ConventionTypeConfiguration <T>(memberInfo, configuration, modelConfiguration)); }
internal virtual void ApplyPropertyConfiguration( PropertyInfo propertyInfo, Func <PropertyConfiguration> propertyConfiguration, System.Data.Entity.ModelConfiguration.Configuration.ModelConfiguration modelConfiguration) { this._conventionsConfiguration.ApplyPropertyConfiguration(propertyInfo, propertyConfiguration, modelConfiguration); }
protected override void InvokeAction( Type memberInfo, System.Data.Entity.ModelConfiguration.Configuration.ModelConfiguration modelConfiguration, TValue value) { this._entityConfigurationAction(new ConventionTypeConfiguration <T>(memberInfo, modelConfiguration), value); }
protected override void ApplyCore( PropertyInfo memberInfo, Func <System.Data.Entity.ModelConfiguration.Configuration.Properties.Primitive.PrimitivePropertyConfiguration> configuration, System.Data.Entity.ModelConfiguration.Configuration.ModelConfiguration modelConfiguration) { this._propertyConfigurationAction(new ConventionPrimitivePropertyConfiguration(memberInfo, configuration)); }
public void Apply_ignores_constraint_when_inverse_constraint_already_specified() { var mockPropertyInfo = typeof(AType4).GetInstanceProperty("B"); var mockInversePropertyInfo = typeof(BType4).GetInstanceProperty("A"); var modelConfiguration = new ModelConfiguration(); var navigationPropertyConfiguration = modelConfiguration.Entity(typeof(AType4)).Navigation(mockPropertyInfo); var inverseNavigationPropertyConfiguration = modelConfiguration.Entity(typeof(BType4)).Navigation(mockInversePropertyInfo); navigationPropertyConfiguration.InverseNavigationProperty = mockInversePropertyInfo; inverseNavigationPropertyConfiguration.Constraint = new ForeignKeyConstraintConfiguration(new[] { typeof(BType4).GetInstanceProperty("AId1") }); new ForeignKeyPrimitivePropertyAttributeConvention() .Apply( typeof(BType4).GetInstanceProperty("AId1"), new ConventionTypeConfiguration(typeof(BType4), () => modelConfiguration.Entity(typeof(BType4)), modelConfiguration), new ForeignKeyAttribute("A")); Assert.Null(navigationPropertyConfiguration.Constraint); }
public void Apply_adds_fk_column_when_nav_prop_is_valid() { var mockTypeA = new MockType("A"); var mockTypeB = new MockType("B").Property<int>("AId").Property(mockTypeA, "A"); var mockPropertyInfo = mockTypeB.GetProperty("AId"); var mockNavigationPropertyInfo = mockTypeB.GetProperty("A"); var modelConfiguration = new ModelConfiguration(); new ForeignKeyPrimitivePropertyAttributeConvention() .Apply( mockPropertyInfo, new ConventionTypeConfiguration(mockTypeB, () => modelConfiguration.Entity(mockTypeB), modelConfiguration), new ForeignKeyAttribute("A")); var navigationPropertyConfiguration = modelConfiguration.Entity(mockTypeB).Navigation(mockNavigationPropertyInfo); Assert.NotNull(navigationPropertyConfiguration.Constraint); var foreignKeyConstraint = (ForeignKeyConstraintConfiguration)navigationPropertyConfiguration.Constraint; Assert.Equal(new[] { mockTypeB.GetProperty("AId") }, foreignKeyConstraint.ToProperties); Assert.Null(navigationPropertyConfiguration.InverseNavigationProperty); }
protected override void ApplyCore(Type memberInfo, ModelConfiguration modelConfiguration) { DebugCheck.NotNull(memberInfo); DebugCheck.NotNull(modelConfiguration); _entityConfigurationAction(new ConventionTypeConfiguration(memberInfo, modelConfiguration)); }
public void Configure_should_uniquify_unconfigured_assocation_function_names() { var typeA = new MockType("A"); var typeB = new MockType("B").Property(typeA.AsCollection(), "As"); var mockPropertyInfo = typeB.GetProperty("As"); typeA.Property(typeB.AsCollection(), "Bs"); var modelConfiguration = new ModelConfiguration(); var navigationPropertyConfiguration = modelConfiguration.Entity(typeB).Navigation(mockPropertyInfo); navigationPropertyConfiguration.ModificationFunctionsConfiguration = new ModificationFunctionsConfiguration(); var modificationFunctionConfiguration = new ModificationFunctionConfiguration(); modificationFunctionConfiguration.HasName("M2M_Delete"); navigationPropertyConfiguration.ModificationFunctionsConfiguration .Insert(modificationFunctionConfiguration); var model = new EdmModel(DataSpace.CSpace); var entityA = model.AddEntityType("A"); entityA.Annotations.SetClrType(typeA); entityA.SetConfiguration(modelConfiguration.Entity(typeA)); var entityB = model.AddEntityType("B"); entityB.Annotations.SetClrType(typeB); entityB.SetConfiguration(modelConfiguration.Entity(typeB)); model.AddEntitySet("AS", entityA); model.AddEntitySet("BS", entityB); var associationType = model.AddAssociationType( "M2M", entityA, RelationshipMultiplicity.Many, entityB, RelationshipMultiplicity.Many); associationType.SetConfiguration(navigationPropertyConfiguration); var navigationProperty = entityB.AddNavigationProperty("As", associationType); navigationProperty.SetClrPropertyInfo(mockPropertyInfo); model.AddAssociationSet("M2MSet", associationType); var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest) .Generate(model); modelConfiguration.Configure(databaseMapping, ProviderRegistry.Sql2008_ProviderManifest); Assert.True(databaseMapping.Database.Functions.Any(f => f.Name == "M2M_Delete")); Assert.True(databaseMapping.Database.Functions.Any(f => f.Name == "M2M_Delete1")); }
public void Apply_ignores_constraint_when_inverse_constraint_already_specified() { var mockTypeA = new MockType("A"); var mockTypeB = new MockType("B").Property(mockTypeA, "A").Property<int>("AId1").Property<int>("AId2"); mockTypeA.Property(mockTypeB, "B"); var mockPropertyInfo = mockTypeA.GetProperty("B"); var mockInversePropertyInfo = mockTypeB.GetProperty("A"); var modelConfiguration = new ModelConfiguration(); var navigationPropertyConfiguration = modelConfiguration.Entity(mockTypeA).Navigation(mockPropertyInfo); var inverseNavigationPropertyConfiguration = modelConfiguration.Entity(mockTypeB).Navigation(mockInversePropertyInfo); navigationPropertyConfiguration.InverseNavigationProperty = mockInversePropertyInfo; inverseNavigationPropertyConfiguration.Constraint = new ForeignKeyConstraintConfiguration(new[] { mockTypeB.GetProperty("AId1") }); new ForeignKeyPrimitivePropertyAttributeConvention.ForeignKeyAttributeConventionImpl() .Apply(mockPropertyInfo, modelConfiguration, new ForeignKeyAttribute("AId2")); Assert.Null(navigationPropertyConfiguration.Constraint); }
public static void ConfigureEdmMetadata(ModelConfiguration modelConfiguration) { //Contract.Requires(modelConfiguration != null); #pragma warning disable 612,618 modelConfiguration.Entity(typeof(EdmMetadata)).ToTable(TableName); #pragma warning restore 612,618 }
protected override void InvokeAction( Type memberInfo, Func <ComplexTypeConfiguration> configuration, System.Data.Entity.ModelConfiguration.Configuration.ModelConfiguration modelConfiguration, T value) { this._entityConfigurationAction(new ConventionTypeConfiguration(memberInfo, configuration, modelConfiguration), value); }
internal DbModelBuilder( ModelConfiguration.Configuration.ModelConfiguration modelConfiguration, DbModelBuilderVersion modelBuilderVersion = DbModelBuilderVersion.Latest) : this( modelConfiguration, new ConventionsConfiguration(SelectConventionSet(modelBuilderVersion)), modelBuilderVersion) { }
internal ConventionTypeConfiguration( Type type, Func<EntityTypeConfiguration> entityTypeConfiguration, ModelConfiguration modelConfiguration) : this(type, entityTypeConfiguration, null, modelConfiguration) { DebugCheck.NotNull(entityTypeConfiguration); }
internal virtual void ApplyPropertyTypeConfiguration <TStructuralTypeConfiguration>( PropertyInfo propertyInfo, Func <TStructuralTypeConfiguration> structuralTypeConfiguration, System.Data.Entity.ModelConfiguration.Configuration.ModelConfiguration modelConfiguration) where TStructuralTypeConfiguration : StructuralTypeConfiguration { this._conventionsConfiguration.ApplyPropertyTypeConfiguration <TStructuralTypeConfiguration>(propertyInfo, structuralTypeConfiguration, modelConfiguration); }
private DbModelBuilder(DbModelBuilder source) { DebugCheck.NotNull(source); _modelConfiguration = source._modelConfiguration.Clone(); _conventionsConfiguration = source._conventionsConfiguration.Clone(); _modelBuilderVersion = source._modelBuilderVersion; }
internal ConventionTypeConfiguration( Type type, Func<ComplexTypeConfiguration> complexTypeConfiguration, ModelConfiguration modelConfiguration) : this(type, null, complexTypeConfiguration, modelConfiguration) { DebugCheck.NotNull(complexTypeConfiguration); }
public static void ConfigureEdmMetadata(ModelConfiguration modelConfiguration) { DebugCheck.NotNull(modelConfiguration); #pragma warning disable 612,618 modelConfiguration.Entity(typeof(EdmMetadata)).ToTable(TableName); #pragma warning restore 612,618 }
internal virtual void ApplyTypeConfiguration <TStructuralTypeConfiguration>( Type type, Func <TStructuralTypeConfiguration> structuralTypeConfiguration, System.Data.Entity.ModelConfiguration.Configuration.ModelConfiguration modelConfiguration) where TStructuralTypeConfiguration : StructuralTypeConfiguration { this._conventionsConfiguration.ApplyTypeConfiguration <TStructuralTypeConfiguration>(type, structuralTypeConfiguration, modelConfiguration); }
public void Add_complex_type_configuration_should_add_to_model_configuration() { var modelConfiguration = new ModelConfiguration(); var complexTypeConfiguration = new ComplexTypeConfiguration<object>(); new ConfigurationRegistrar(modelConfiguration).Add(complexTypeConfiguration); Assert.Same(complexTypeConfiguration.Configuration, modelConfiguration.ComplexType(typeof(object))); }
protected override void ApplyCore( PropertyInfo memberInfo, Func<PrimitivePropertyConfiguration> configuration, ModelConfiguration modelConfiguration) { DebugCheck.NotNull(memberInfo); DebugCheck.NotNull(configuration); DebugCheck.NotNull(modelConfiguration); _propertyConfigurationAction(new ConventionPrimitivePropertyConfiguration(memberInfo, configuration)); }
private ModelConfiguration(ModelConfiguration source) { source._entityConfigurations.Each(c => _entityConfigurations.Add(c.Key, c.Value.Clone())); source._complexTypeConfigurations.Each(c => _complexTypeConfigurations.Add(c.Key, c.Value.Clone())); _ignoredTypes.AddRange(source._ignoredTypes); DefaultSchema = source.DefaultSchema; }
public void Apply_should_set_model_namespace() { var convention = new ModelNamespaceConvention("Foo"); var modelConfiguration = new ModelConfiguration(); convention.Apply(modelConfiguration); Assert.Equal("Foo", modelConfiguration.ModelNamespace); }
public void Configure_should_uniquify_unconfigured_association_function_names() { var mockPropertyInfo = typeof(BType1).GetDeclaredProperty("As"); var modelConfiguration = new ModelConfiguration(); var navigationPropertyConfiguration = modelConfiguration.Entity(typeof(BType1)).Navigation(mockPropertyInfo); navigationPropertyConfiguration.ModificationStoredProceduresConfiguration = new ModificationStoredProceduresConfiguration(); var modificationFunctionConfiguration = new ModificationStoredProcedureConfiguration(); modificationFunctionConfiguration.HasName("AB_Delete"); navigationPropertyConfiguration.ModificationStoredProceduresConfiguration .Insert(modificationFunctionConfiguration); var model = new EdmModel(DataSpace.CSpace); var entityA = model.AddEntityType("A"); entityA.GetMetadataProperties().SetClrType(typeof(AType1)); entityA.SetConfiguration(modelConfiguration.Entity(typeof(AType1))); var entityB = model.AddEntityType("B"); entityB.GetMetadataProperties().SetClrType(typeof(BType1)); entityB.SetConfiguration(modelConfiguration.Entity(typeof(BType1))); model.AddEntitySet("AS", entityA); model.AddEntitySet("BS", entityB); var associationType = model.AddAssociationType( "M2M", entityA, RelationshipMultiplicity.Many, entityB, RelationshipMultiplicity.Many); associationType.SetConfiguration(navigationPropertyConfiguration); var navigationProperty = entityB.AddNavigationProperty("As", associationType); navigationProperty.SetClrPropertyInfo(mockPropertyInfo); model.AddAssociationSet("M2MSet", associationType); var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderInfo, ProviderRegistry.Sql2008_ProviderManifest) .Generate(model); modelConfiguration.Configure(databaseMapping, ProviderRegistry.Sql2008_ProviderManifest); Assert.True(databaseMapping.Database.Functions.Any(f => f.StoreFunctionNameAttribute == "AB_Delete")); Assert.True(databaseMapping.Database.Functions.Any(f => f.StoreFunctionNameAttribute == "AB_Delete1")); }
public void Add_entity_configuration_should_add_to_model_configuration() { var modelConfiguration = new ModelConfiguration(); var entityConfiguration = new EntityTypeConfiguration<object>(); new ConfigurationRegistrar(modelConfiguration).Add(entityConfiguration); Assert.Same(entityConfiguration.Configuration, modelConfiguration.Entity(typeof(object))); }
public void IsComplexType_configures() { var type = typeof(LocalEntityType); var innerConfig = new ModelConfiguration(); var config = new ConventionTypeConfiguration<LocalEntityType>(type, innerConfig); config.IsComplexType(); Assert.True(innerConfig.IsComplexType(typeof(LocalEntityType))); }
public void Get_configured_types_should_return_types() { var modelConfiguration = new ModelConfiguration(); var configurationRegistrar = new ConfigurationRegistrar(modelConfiguration) .Add(new ComplexTypeConfiguration<object>()) .Add(new EntityTypeConfiguration<string>()); Assert.Equal(2, configurationRegistrar.GetConfiguredTypes().Count()); }
public void Apply_should_inline_type() { var mockType = new MockType(); var modelConfiguration = new ModelConfiguration(); new ComplexTypeAttributeConvention.ComplexTypeAttributeConventionImpl() .Apply(mockType, modelConfiguration, new ComplexTypeAttribute()); Assert.True(modelConfiguration.IsComplexType(mockType)); }
public void Apply_should_ignore_type() { var mockType = new MockType(); var modelConfiguration = new ModelConfiguration(); new NotMappedTypeAttributeConvention.NotMappedTypeAttributeConventionImpl() .Apply(mockType, modelConfiguration, new NotMappedAttribute()); Assert.True(modelConfiguration.IsIgnoredType(mockType)); }
private DbModelBuilder( System.Data.Entity.ModelConfiguration.Configuration.ModelConfiguration modelConfiguration, ConventionsConfiguration conventionsConfiguration, DbModelBuilderVersion modelBuilderVersion = DbModelBuilderVersion.Latest) { if (!Enum.IsDefined(typeof(DbModelBuilderVersion), (object)modelBuilderVersion)) { throw new ArgumentOutOfRangeException(nameof(modelBuilderVersion)); } this._modelConfiguration = modelConfiguration; this._conventionsConfiguration = conventionsConfiguration; this._modelBuilderVersion = modelBuilderVersion; }
public MappingContext( System.Data.Entity.ModelConfiguration.Configuration.ModelConfiguration modelConfiguration, ConventionsConfiguration conventionsConfiguration, EdmModel model, DbModelBuilderVersion modelBuilderVersion = DbModelBuilderVersion.Latest, AttributeProvider attributeProvider = null) { this._modelConfiguration = modelConfiguration; this._conventionsConfiguration = conventionsConfiguration; this._model = model; this._modelBuilderVersion = modelBuilderVersion; this._attributeProvider = attributeProvider ?? new AttributeProvider(); }
protected override void ApplyCore( PropertyInfo memberInfo, Func <System.Data.Entity.ModelConfiguration.Configuration.Properties.Primitive.PrimitivePropertyConfiguration> configuration, System.Data.Entity.ModelConfiguration.Configuration.ModelConfiguration modelConfiguration) { T obj = this._capturingPredicate(memberInfo); if ((object)obj == null) { return; } this._propertyConfigurationAction(new ConventionPrimitivePropertyConfiguration(memberInfo, configuration), obj); }
public void Map_should_not_detect_arrays_as_collection_associations() { var modelConfiguration = new ModelConfiguration(); var model = new EdmModel().Initialize(); var entityType = new EdmEntityType(); var mappingContext = new MappingContext(modelConfiguration, new ConventionsConfiguration(), model); new NavigationPropertyMapper(new TypeMapper(mappingContext)) .Map(new MockPropertyInfo(typeof(NavigationPropertyMapperTests[]), "Nav"), entityType, () => new EntityTypeConfiguration(typeof(object))); Assert.Equal(0, model.Namespaces.Single().AssociationTypes.Count); }
public MappingContext( ModelConfiguration modelConfiguration, ConventionsConfiguration conventionsConfiguration, EdmModel model) { //Contract.Requires(modelConfiguration != null); //Contract.Requires(conventionsConfiguration != null); //Contract.Requires(model != null); _modelConfiguration = modelConfiguration; _conventionsConfiguration = conventionsConfiguration; _model = model; _attributeProvider = new AttributeProvider(); }
private ConventionTypeConfiguration( Type type, Func<EntityTypeConfiguration> entityTypeConfiguration, Func<ComplexTypeConfiguration> complexTypeConfiguration, ModelConfiguration modelConfiguration) { DebugCheck.NotNull(type); DebugCheck.NotNull(modelConfiguration); _type = type; _entityTypeConfiguration = entityTypeConfiguration; _complexTypeConfiguration = complexTypeConfiguration; _modelConfiguration = modelConfiguration; }
public void AddFromAssembly_should_add_all_configuration_to_model_configuration() { var modelConfiguration = new ModelConfiguration(); new ConfigurationRegistrar(modelConfiguration).AddFromAssembly(CreateDynamicAssemblyWithStructuralTypeConfigurations()); Assert.Equal(3, modelConfiguration.ComplexTypes.Count()); Assert.Equal(3, modelConfiguration.Entities.Count()); Assert.Equal(1, modelConfiguration.ConfiguredTypes.Count(t => t.Name == "Entity1")); Assert.Equal(1, modelConfiguration.ConfiguredTypes.Count(t => t.Name == "Complex1")); Assert.Equal(1, modelConfiguration.ConfiguredTypes.Count(t => t.Name == "Entity2")); Assert.Equal(1, modelConfiguration.ConfiguredTypes.Count(t => t.Name == "Complex2")); Assert.Equal(1, modelConfiguration.ConfiguredTypes.Count(t => t.Name == "Entity3")); Assert.Equal(1, modelConfiguration.ConfiguredTypes.Count(t => t.Name == "Complex3")); }
public void Apply_finds_inverse_when_optional_to_optional() { var propertyInfo = typeof(BType3).GetInstanceProperty("A"); var modelConfiguration = new ModelConfiguration(); new InversePropertyAttributeConvention() .Apply( propertyInfo, new ConventionTypeConfiguration(typeof(BType3), () => modelConfiguration.Entity(typeof(BType3)), modelConfiguration), new InversePropertyAttribute("B")); var navigationPropertyConfiguration = modelConfiguration.Entity(typeof(BType3)).Navigation(propertyInfo); Assert.Same(typeof(AType3).GetDeclaredProperty("B"), navigationPropertyConfiguration.InverseNavigationProperty); }
public void Apply_finds_inverse_when_many_to_many() { var mockTypeA = new MockType("A"); var mockTypeB = new MockType("B").Property(mockTypeA.AsCollection(), "As"); var mockPropertyInfo = mockTypeB.GetProperty("As"); mockTypeA.Property(mockTypeB.AsCollection(), "Bs"); var modelConfiguration = new ModelConfiguration(); new InversePropertyAttributeConvention() .Apply(mockPropertyInfo, modelConfiguration, new InversePropertyAttribute("Bs")); var navigationPropertyConfiguration = modelConfiguration.Entity(mockTypeB).Navigation(mockPropertyInfo); Assert.Same(mockTypeA.GetProperty("Bs"), navigationPropertyConfiguration.InverseNavigationProperty); }
private DbModelBuilder( ModelConfiguration.Configuration.ModelConfiguration modelConfiguration, ConventionsConfiguration conventionsConfiguration, DbModelBuilderVersion modelBuilderVersion = DbModelBuilderVersion.Latest) { DebugCheck.NotNull(modelConfiguration); DebugCheck.NotNull(conventionsConfiguration); if (!(Enum.IsDefined(typeof(DbModelBuilderVersion), modelBuilderVersion))) { throw new ArgumentOutOfRangeException("modelBuilderVersion"); } _modelConfiguration = modelConfiguration; _conventionsConfiguration = conventionsConfiguration; _modelBuilderVersion = modelBuilderVersion; }
public virtual void AddConfigurationTypesToModel(IEnumerable<Type> types, ModelConfiguration modelConfiguration) { DebugCheck.NotNull(types); DebugCheck.NotNull(modelConfiguration); foreach (var type in types) { if (_filter.IsEntityTypeConfiguration(type)) { modelConfiguration.Add(_activator.Activate<EntityTypeConfiguration>(type)); } else if (_filter.IsComplexTypeConfiguration(type)) { modelConfiguration.Add(_activator.Activate<ComplexTypeConfiguration>(type)); } } }
public MappingContext( ModelConfiguration modelConfiguration, ConventionsConfiguration conventionsConfiguration, EdmModel model, DbModelBuilderVersion modelBuilderVersion = DbModelBuilderVersion.Latest, AttributeProvider attributeProvider = null) { DebugCheck.NotNull(modelConfiguration); DebugCheck.NotNull(conventionsConfiguration); DebugCheck.NotNull(model); _modelConfiguration = modelConfiguration; _conventionsConfiguration = conventionsConfiguration; _model = model; _modelBuilderVersion = modelBuilderVersion; _attributeProvider = attributeProvider ?? new AttributeProvider(); }
public void Map_should_detect_collection_associations_and_set_correct_end_kinds() { var modelConfiguration = new ModelConfiguration(); var model = new EdmModel().Initialize(); var entityType = new EdmEntityType(); var mappingContext = new MappingContext(modelConfiguration, new ConventionsConfiguration(), model); new NavigationPropertyMapper(new TypeMapper(mappingContext)) .Map(new MockPropertyInfo(typeof(List<NavigationPropertyMapperTests>), "Nav"), entityType, () => new EntityTypeConfiguration(typeof(object))); Assert.Equal(1, model.Namespaces.Single().AssociationTypes.Count); var associationType = model.Namespaces.Single().AssociationTypes.Single(); Assert.Equal(EdmAssociationEndKind.Optional, associationType.SourceEnd.EndKind); Assert.Equal(EdmAssociationEndKind.Many, associationType.TargetEnd.EndKind); }
public void AddConfigurationTypesToModel_adds_entitytypeconfigurations_into_model() { var entityTypeConfiguration = new EntityTypeConfiguration(typeof(Random)); var filter = new Mock<ConfigurationTypeFilter>(); filter.Setup(f => f.IsEntityTypeConfiguration(It.IsAny<Type>())).Returns(true); var activator = new Mock<ConfigurationTypeActivator>(); activator.Setup(a => a.Activate<EntityTypeConfiguration>(It.IsAny<Type>())) .Returns(entityTypeConfiguration); var finder = new ConfigurationTypesFinder(activator.Object, filter.Object); var modelConfiguration = new ModelConfiguration(); finder.AddConfigurationTypesToModel(new[] { typeof(Object) }, modelConfiguration); Assert.Same(entityTypeConfiguration, modelConfiguration.Entity(typeof(Random))); }
public void AddConfigurationTypesToModel_adds_entitytypeconfigurations_into_model() { var entityTypeConfiguration = new EntityTypeConfiguration(typeof(Random)); var filter = new Mock <ConfigurationTypeFilter>(); filter.Setup(f => f.IsEntityTypeConfiguration(It.IsAny <Type>())).Returns(true); var activator = new Mock <ConfigurationTypeActivator>(); activator.Setup(a => a.Activate <EntityTypeConfiguration>(It.IsAny <Type>())) .Returns(entityTypeConfiguration); var finder = new ConfigurationTypesFinder(activator.Object, filter.Object); var modelConfiguration = new ModelConfiguration(); finder.AddConfigurationTypesToModel(new[] { typeof(Object) }, modelConfiguration); Assert.Same(entityTypeConfiguration, modelConfiguration.Entity(typeof(Random))); }
internal virtual void ApplyModelConfiguration(ModelConfiguration modelConfiguration) { DebugCheck.NotNull(modelConfiguration); // PERF: this code is part of a critical path, consider its performance when refactoring for (var i = _configurationConventions.Count - 1; i >= 0; --i) { var convention = _configurationConventions[i]; var configurationConvention = convention as IConfigurationConvention; configurationConvention?.Apply(modelConfiguration); var lightweightConfigurationConvention = convention as Convention; if (lightweightConfigurationConvention != null) { lightweightConfigurationConvention.ApplyModelConfiguration(modelConfiguration); } } }
internal virtual void ApplyPropertyTypeConfiguration <TStructuralTypeConfiguration>( PropertyInfo propertyInfo, Func <TStructuralTypeConfiguration> structuralTypeConfiguration, ModelConfiguration modelConfiguration) where TStructuralTypeConfiguration : StructuralTypeConfiguration { DebugCheck.NotNull(propertyInfo); DebugCheck.NotNull(structuralTypeConfiguration); // PERF: this code is part of a critical path, consider its performance when refactoring for (var i = _configurationConventions.Count - 1; i >= 0; --i) { var convention = _configurationConventions[i]; var propertyTypeConfigurationConvention = convention as IConfigurationConvention <PropertyInfo, TStructuralTypeConfiguration>; if (propertyTypeConfigurationConvention != null) { propertyTypeConfigurationConvention.Apply(propertyInfo, structuralTypeConfiguration, modelConfiguration); } var structuralTypeConfigurationConvention = convention as IConfigurationConvention <PropertyInfo, StructuralTypeConfiguration>; if (structuralTypeConfigurationConvention != null) { structuralTypeConfigurationConvention.Apply(propertyInfo, structuralTypeConfiguration, modelConfiguration); } var lightweightConfigurationConvention = convention as Convention; if (lightweightConfigurationConvention != null) { lightweightConfigurationConvention.ApplyPropertyTypeConfiguration( propertyInfo, structuralTypeConfiguration, modelConfiguration); } } }
internal virtual void ApplyModelConfiguration(ModelConfiguration modelConfiguration) { DebugCheck.NotNull(modelConfiguration); foreach (var convention in ((IList <IConvention>)_configurationConventions).Reverse()) { var configurationConvention = convention as IConfigurationConvention; if (configurationConvention != null) { configurationConvention.Apply(modelConfiguration); } var lightweightConfigurationConvention = convention as Convention; if (lightweightConfigurationConvention != null) { lightweightConfigurationConvention.ApplyModelConfiguration(modelConfiguration); } } }
internal virtual void ApplyPropertyTypeConfiguration <TStructuralTypeConfiguration>( PropertyInfo propertyInfo, Func <TStructuralTypeConfiguration> structuralTypeConfiguration, ModelConfiguration modelConfiguration) where TStructuralTypeConfiguration : StructuralTypeConfiguration { DebugCheck.NotNull(propertyInfo); DebugCheck.NotNull(structuralTypeConfiguration); foreach (var convention in ((IList <IConvention>)_configurationConventions).Reverse()) { var propertyTypeConfigurationConvention = convention as IConfigurationConvention <PropertyInfo, TStructuralTypeConfiguration>; if (propertyTypeConfigurationConvention != null) { propertyTypeConfigurationConvention.Apply(propertyInfo, structuralTypeConfiguration, modelConfiguration); } var structuralTypeConfigurationConvention = convention as IConfigurationConvention <PropertyInfo, StructuralTypeConfiguration>; if (structuralTypeConfigurationConvention != null) { structuralTypeConfigurationConvention.Apply(propertyInfo, structuralTypeConfiguration, modelConfiguration); } var lightweightConfigurationConvention = convention as Convention; if (lightweightConfigurationConvention != null) { lightweightConfigurationConvention.ApplyPropertyTypeConfiguration( propertyInfo, structuralTypeConfiguration, modelConfiguration); } } }
internal virtual void ApplyTypeConfiguration <TStructuralTypeConfiguration>( Type type, Func <TStructuralTypeConfiguration> structuralTypeConfiguration, ModelConfiguration modelConfiguration) where TStructuralTypeConfiguration : StructuralTypeConfiguration { DebugCheck.NotNull(type); DebugCheck.NotNull(structuralTypeConfiguration); foreach (var convention in _configurationConventions) { var propertyTypeConfigurationConvention = convention as IConfigurationConvention <Type, TStructuralTypeConfiguration>; if (propertyTypeConfigurationConvention != null) { propertyTypeConfigurationConvention.Apply(type, structuralTypeConfiguration, modelConfiguration); } var structuralTypeConfigurationConvention = convention as IConfigurationConvention <Type, StructuralTypeConfiguration>; if (structuralTypeConfigurationConvention != null) { structuralTypeConfigurationConvention.Apply(type, structuralTypeConfiguration, modelConfiguration); } var lightweightConfigurationConvention = convention as Convention; if (lightweightConfigurationConvention != null) { lightweightConfigurationConvention.ApplyTypeConfiguration(type, structuralTypeConfiguration, modelConfiguration); } } }
internal virtual void ApplyModelConfiguration(Type type, ModelConfiguration modelConfiguration) { DebugCheck.NotNull(type); DebugCheck.NotNull(modelConfiguration); foreach (var convention in _configurationConventions) { var modelConfigurationConvention = convention as IConfigurationConvention <Type>; if (modelConfigurationConvention != null) { modelConfigurationConvention.Apply(type, modelConfiguration); } var lightweightConfigurationConvention = convention as Convention; if (lightweightConfigurationConvention != null) { lightweightConfigurationConvention.ApplyModelConfiguration(type, modelConfiguration); } } }
internal virtual void ApplyPropertyConfiguration(PropertyInfo propertyInfo, ModelConfiguration modelConfiguration) { DebugCheck.NotNull(propertyInfo); DebugCheck.NotNull(modelConfiguration); foreach (var convention in ((IList <IConvention>)_configurationConventions).Reverse()) { var propertyConfigurationConvention = convention as IConfigurationConvention <PropertyInfo>; if (propertyConfigurationConvention != null) { propertyConfigurationConvention.Apply(propertyInfo, modelConfiguration); } var lightweightConfigurationConvention = convention as Convention; if (lightweightConfigurationConvention != null) { lightweightConfigurationConvention.ApplyPropertyConfiguration(propertyInfo, modelConfiguration); } } }
internal ConfigurationRegistrar(ModelConfiguration modelConfiguration) { DebugCheck.NotNull(modelConfiguration); _modelConfiguration = modelConfiguration; }
internal virtual void ApplyModelConfiguration(Type type, System.Data.Entity.ModelConfiguration.Configuration.ModelConfiguration modelConfiguration) { this._conventionsConfiguration.ApplyModelConfiguration(type, modelConfiguration); }
internal virtual void ApplyPropertyConfiguration( PropertyInfo propertyInfo, Func <PropertyConfiguration> propertyConfiguration, ModelConfiguration modelConfiguration) { DebugCheck.NotNull(propertyInfo); DebugCheck.NotNull(propertyConfiguration); var propertyConfigurationType = StructuralTypeConfiguration.GetPropertyConfigurationType(propertyInfo.PropertyType); foreach (var convention in ((IList <IConvention>)_configurationConventions).Reverse()) { new PropertyConfigurationConventionDispatcher( convention, propertyConfigurationType, propertyInfo, propertyConfiguration, modelConfiguration) .Dispatch(); var lightweightConfigurationConvention = convention as Convention; if (lightweightConfigurationConvention != null) { lightweightConfigurationConvention.ApplyPropertyConfiguration(propertyInfo, propertyConfiguration, modelConfiguration); } } }
private DbModelBuilder(DbModelBuilder source) { this._modelConfiguration = source._modelConfiguration.Clone(); this._conventionsConfiguration = source._conventionsConfiguration.Clone(); this._modelBuilderVersion = source._modelBuilderVersion; }
internal DbModelBuilder( System.Data.Entity.ModelConfiguration.Configuration.ModelConfiguration modelConfiguration, DbModelBuilderVersion modelBuilderVersion = DbModelBuilderVersion.Latest) : this(modelConfiguration, new ConventionsConfiguration(DbModelBuilder.SelectConventionSet(modelBuilderVersion)), modelBuilderVersion) { }
protected override void ApplyCore(Type memberInfo, System.Data.Entity.ModelConfiguration.Configuration.ModelConfiguration modelConfiguration) { this._entityConfigurationAction(new ConventionTypeConfiguration(memberInfo, modelConfiguration)); }
internal ConventionTypeConfiguration( Type type, ModelConfiguration modelConfiguration) : this(type, null, null, modelConfiguration) { }
internal virtual void ApplyPropertyConfiguration( PropertyInfo propertyInfo, Func <PropertyConfiguration> propertyConfiguration, ModelConfiguration modelConfiguration) { DebugCheck.NotNull(propertyInfo); DebugCheck.NotNull(propertyConfiguration); var propertyConfigurationType = StructuralTypeConfiguration.GetPropertyConfigurationType(propertyInfo.PropertyType); // PERF: this code is part of a critical path, consider its performance when refactoring for (var i = _configurationConventions.Count - 1; i >= 0; --i) { var convention = _configurationConventions[i]; new PropertyConfigurationConventionDispatcher( convention, propertyConfigurationType, propertyInfo, propertyConfiguration, modelConfiguration) .Dispatch(); var lightweightConfigurationConvention = convention as Convention; if (lightweightConfigurationConvention != null) { lightweightConfigurationConvention.ApplyPropertyConfiguration(propertyInfo, propertyConfiguration, modelConfiguration); } } }