public virtual InternalModelBuilder Apply(InternalModelBuilder modelBuilder)
{
modelBuilder.RemoveEntityTypesUnreachableByNavigations(ConfigurationSource.DataAnnotation);
RemoveNavigationlessForeignKeys(modelBuilder);
return modelBuilder;
}
public virtual InternalModelBuilder Apply(InternalModelBuilder modelBuilder)
{
modelBuilder.Annotation(
SqlServerAnnotationNames.Prefix + SqlServerAnnotationNames.ValueGeneration,
SqlServerValueGenerationStrategy.Sequence.ToString(),
ConfigurationSource.Convention);
var sequence = new Sequence(Sequence.DefaultName) { Model = modelBuilder.Metadata };
modelBuilder.Annotation(
SqlServerAnnotationNames.Prefix + RelationalAnnotationNames.Sequence + sequence.Schema + "." + sequence.Name,
sequence.Serialize(),
ConfigurationSource.Convention
);
modelBuilder.Annotation(
SqlServerAnnotationNames.Prefix + SqlServerAnnotationNames.DefaultSequenceName,
sequence.Name,
ConfigurationSource.Convention);
modelBuilder.Annotation(
SqlServerAnnotationNames.Prefix + SqlServerAnnotationNames.DefaultSequenceSchema,
sequence.Schema,
ConfigurationSource.Convention);
return modelBuilder;
}
private InternalIndexBuilder CreateInternalIndexBuilder()
{
var modelBuilder = new InternalModelBuilder(new Model());
var entityBuilder = modelBuilder.Entity(typeof(Customer), ConfigurationSource.Explicit);
return entityBuilder.HasIndex(new[] { Customer.IdProperty, Customer.NameProperty }, ConfigurationSource.Explicit);
}
public void Does_not_throw_when_primitive_type_is_ignored()
{
var modelBuilder = new InternalModelBuilder(new Model(), new ConventionSet());
var entityTypeBuilder = modelBuilder.Entity(typeof(PrimitivePropertyEntity), ConfigurationSource.Convention);
entityTypeBuilder.Ignore("Property", ConfigurationSource.Convention);
new RelationalPropertyMappingValidationConvention(new TestRelationalTypeMapper()).Apply(modelBuilder);
}
public virtual void Does_not_throw_when_primitive_type_property_is_ignored()
{
var modelBuilder = new InternalModelBuilder(new Model());
var entityTypeBuilder = modelBuilder.Entity(typeof(PrimitivePropertyEntity), ConfigurationSource.Convention);
entityTypeBuilder.Ignore("Property", ConfigurationSource.Convention);
CreateConvention().Apply(modelBuilder);
}
public void Throws_when_primitive_type_is_not_added_or_ignored()
{
var modelBuilder = new InternalModelBuilder(new Model(), new ConventionSet());
var entityTypeBuilder = modelBuilder.Entity(typeof(PrimitivePropertyEntity), ConfigurationSource.Convention);
Assert.Equal(CoreStrings.PropertyNotAdded("Property", typeof(PrimitivePropertyEntity).FullName),
Assert.Throws<InvalidOperationException>(() => new RelationalPropertyMappingValidationConvention(new TestRelationalTypeMapper()).Apply(modelBuilder)).Message);
}
public void Throws_when_navigation_is_not_added_or_ignored()
{
var modelBuilder = new InternalModelBuilder(new Model(), new ConventionSet());
var entityTypeBuilder = modelBuilder.Entity(typeof(NavigationEntity), ConfigurationSource.Convention);
Assert.Equal(CoreStrings.NavigationNotAdded("Navigation", typeof(NavigationEntity).FullName),
Assert.Throws<InvalidOperationException>(() => new PropertyMappingValidationConvention().Apply(modelBuilder)).Message);
}
public virtual InternalModelBuilder Apply(InternalModelBuilder modelBuilder)
{
modelBuilder.Annotation(
SqlServerAnnotationNames.Prefix + SqlServerAnnotationNames.ValueGeneration,
SqlServerValueGenerationStrategy.Sequence.ToString(),
ConfigurationSource.Convention);
return modelBuilder;
}
public void Does_not_throw_when_primitive_type_is_added()
{
var modelBuilder = new InternalModelBuilder(new Model(), new ConventionSet());
var entityTypeBuilder = modelBuilder.Entity(typeof(PrimitivePropertyEntity), ConfigurationSource.Convention);
entityTypeBuilder.Property("Property", typeof(int), ConfigurationSource.Convention);
new PropertyMappingValidationConvention().Apply(modelBuilder);
}
public void Does_not_throw_when_navigation_is_ignored()
{
var modelBuilder = new InternalModelBuilder(new Model(), new ConventionSet());
var entityTypeBuilder = modelBuilder.Entity(typeof(NavigationEntity), ConfigurationSource.Convention);
entityTypeBuilder.Ignore("Navigation", ConfigurationSource.Convention);
new PropertyMappingValidationConvention().Apply(modelBuilder);
}
public virtual void Throws_when_navigation_is_not_added_or_ignored()
{
var modelBuilder = new InternalModelBuilder(new Model());
var entityTypeBuilder = modelBuilder.Entity(typeof(NavigationEntity), ConfigurationSource.Convention);
Assert.Equal(
CoreStrings.NavigationNotAdded(typeof(NavigationEntity).DisplayName(fullName: false), "Navigation", typeof(PrimitivePropertyEntity).Name),
Assert.Throws<InvalidOperationException>(() => CreateConvention().Apply(modelBuilder)).Message);
}
public void Throws_when_added_property_is_not_primitive_type()
{
var modelBuilder = new InternalModelBuilder(new Model(), new ConventionSet());
var entityTypeBuilder = modelBuilder.Entity(typeof(NonPrimitiveAsPropertyEntity), ConfigurationSource.Convention);
entityTypeBuilder.Property("Property", typeof(NavigationAsProperty), ConfigurationSource.Convention);
Assert.Equal(CoreStrings.PropertyNotMapped("Property", typeof(NonPrimitiveAsPropertyEntity).FullName),
Assert.Throws<InvalidOperationException>(() => new PropertyMappingValidationConvention().Apply(modelBuilder)).Message);
}
public void Throws_when_added_property_is_not_mapped_to_store_even_if_configured_to_use_column_type()
{
var modelBuilder = new InternalModelBuilder(new Model(), new ConventionSet());
var entityTypeBuilder = modelBuilder.Entity(typeof(NonPrimitiveAsPropertyEntity), ConfigurationSource.Convention);
entityTypeBuilder.Property("Property", typeof(long), ConfigurationSource.Convention).Relational(ConfigurationSource.Convention).ColumnType("some_int_mapping");
Assert.Equal(CoreStrings.PropertyNotMapped("Property", typeof(NonPrimitiveAsPropertyEntity).FullName),
Assert.Throws<InvalidOperationException>(() => new RelationalPropertyMappingValidationConvention(new TestRelationalTypeMapper()).Apply(modelBuilder)).Message);
}
public void NotMappedAttribute_does_not_override_configuration_from_explicit_source()
{
var modelBuilder = new InternalModelBuilder(new Model(), new ConventionSet());
var entityBuilder = modelBuilder.Entity(typeof(A), ConfigurationSource.Explicit);
new NotMappedEntityTypeAttributeConvention().Apply(entityBuilder);
Assert.Equal(1, modelBuilder.Metadata.EntityTypes.Count);
}
public virtual void Throws_when_nonprimitive_value_type_property_is_not_added_or_ignored()
{
var modelBuilder = new InternalModelBuilder(new Model());
var entityTypeBuilder = modelBuilder.Entity(typeof(NonPrimitiveValueTypePropertyEntity), ConfigurationSource.Convention);
Assert.Equal(
CoreStrings.PropertyNotAdded(
typeof(NonPrimitiveValueTypePropertyEntity).DisplayName(fullName: false), "Property", typeof(CancellationToken).Name),
Assert.Throws<InvalidOperationException>(() => CreateConvention().Apply(modelBuilder)).Message);
}
public void Throws_when_added_property_is_not_mapped_to_store_even_if_configured_to_use_column_type()
{
var modelBuilder = new InternalModelBuilder(new Model());
var entityTypeBuilder = modelBuilder.Entity(typeof(NonPrimitiveAsPropertyEntity), ConfigurationSource.Convention);
entityTypeBuilder.Property("LongProperty", typeof(long), ConfigurationSource.Convention).Relational(ConfigurationSource.Convention).HasColumnType("some_int_mapping");
Assert.Equal(CoreStrings.PropertyNotMapped(
typeof(NonPrimitiveAsPropertyEntity).DisplayName(fullName: false), "LongProperty", typeof(long).DisplayName(fullName: false)),
Assert.Throws<InvalidOperationException>(() => CreateConvention().Apply(modelBuilder)).Message);
}
public void NotMappedAttribute_overrides_configuration_from_convention_source()
{
var modelBuilder = new InternalModelBuilder(new Model());
var entityBuilder = modelBuilder.Entity(typeof(A), ConfigurationSource.Convention);
new NotMappedEntityTypeAttributeConvention().Apply(entityBuilder);
Assert.Equal(0, modelBuilder.Metadata.GetEntityTypes().Count());
}
public void Does_not_throw_when_navigation_is_added()
{
var modelBuilder = new InternalModelBuilder(new Model(), new ConventionSet());
var entityTypeBuilder = modelBuilder.Entity(typeof(NavigationEntity), ConfigurationSource.Convention);
var referencedEntityTypeBuilder = modelBuilder.Entity(typeof(PrimitivePropertyEntity), ConfigurationSource.Convention);
referencedEntityTypeBuilder.Ignore("Property", ConfigurationSource.Convention);
entityTypeBuilder.Relationship(referencedEntityTypeBuilder, "Navigation", null, ConfigurationSource.Convention);
new PropertyMappingValidationConvention().Apply(modelBuilder);
}
public void Property_added_by_name_is_non_shadow_if_matches_Clr_property()
{
var model = new Model();
var modelBuilder = new InternalModelBuilder(model);
var entityBuilder = modelBuilder.Entity(typeof(Customer), ConfigurationSource.Explicit);
var builder = entityBuilder.Property(Customer.NameProperty.Name, ConfigurationSource.Convention);
var property = builder.Metadata;
Assert.Equal(typeof(string), property.ClrType);
Assert.False(property.IsShadowProperty);
}
public virtual void Throws_when_added_property_is_not_of_primitive_type()
{
var modelBuilder = new InternalModelBuilder(new Model());
var entityTypeBuilder = modelBuilder.Entity(typeof(NonPrimitiveAsPropertyEntity), ConfigurationSource.Convention);
entityTypeBuilder.Property("Property", typeof(NavigationAsProperty), ConfigurationSource.Convention);
Assert.Equal(CoreStrings.PropertyNotMapped(
typeof(NonPrimitiveAsPropertyEntity).DisplayName(fullName: false),
"Property",
typeof(NavigationAsProperty).DisplayName(fullName: false)),
Assert.Throws<InvalidOperationException>(() => CreateConvention().Apply(modelBuilder)).Message);
}
public virtual InternalModelBuilder Apply(InternalModelBuilder modelBuilder)
{
Check.NotNull(modelBuilder, nameof(modelBuilder));
foreach (var entityType in modelBuilder.Metadata.GetEntityTypes())
{
var unmappedProperty = entityType.GetProperties().FirstOrDefault(p => !IsMappedPrimitiveProperty(((IProperty)p).ClrType));
if (unmappedProperty != null)
{
throw new InvalidOperationException(CoreStrings.PropertyNotMapped(unmappedProperty.Name, entityType.Name));
}
if (entityType.HasClrType())
{
var clrProperties = new HashSet<string>();
clrProperties.UnionWith(entityType.ClrType.GetRuntimeProperties()
.Where(pi => pi.IsCandidateProperty())
.Select(pi => pi.Name));
clrProperties.ExceptWith(entityType.GetProperties().Select(p => p.Name));
clrProperties.ExceptWith(entityType.GetNavigations().Select(p => p.Name));
var entityTypeBuilder = modelBuilder.Entity(entityType.ClrType, ConfigurationSource.Convention);
clrProperties.RemoveWhere(p => entityTypeBuilder.IsIgnored(p, ConfigurationSource.Convention));
if (clrProperties.Count > 0)
{
foreach (var clrProperty in clrProperties)
{
var actualProperty = entityType.ClrType.GetRuntimeProperty(clrProperty);
var targetType = FindCandidateNavigationPropertyType(actualProperty);
if (targetType != null)
{
if (!modelBuilder.IsIgnored(targetType.DisplayName(), ConfigurationSource.Convention))
{
throw new InvalidOperationException(CoreStrings.NavigationNotAdded(actualProperty.Name, entityType.Name));
}
}
else
{
throw new InvalidOperationException(CoreStrings.PropertyNotAdded(actualProperty.Name, entityType.Name));
}
}
}
}
}
return modelBuilder;
}
private static void RemoveNavigationlessForeignKeys(InternalModelBuilder modelBuilder)
{
foreach (var entityType in modelBuilder.Metadata.GetEntityTypes())
{
foreach (var foreignKey in entityType.GetDeclaredForeignKeys().ToList())
{
if (foreignKey.PrincipalToDependent == null
&& foreignKey.DependentToPrincipal == null)
{
entityType.Builder.RemoveForeignKey(foreignKey, ConfigurationSource.DataAnnotation);
}
}
}
}
public void Can_only_override_existing_ClrType_value_explicitly()
{
var model = new Model();
model.AddEntityType(typeof(Customer)).AddProperty(Customer.NameProperty);
var modelBuilder = new InternalModelBuilder(model, new ConventionSet());
var entityBuilder = modelBuilder.Entity(typeof(Customer), ConfigurationSource.Explicit);
var builder = entityBuilder.Property(Customer.NameProperty.Name, ConfigurationSource.Convention);
Assert.True(builder.ClrType(typeof(string), ConfigurationSource.DataAnnotation));
Assert.False(builder.ClrType(typeof(int), ConfigurationSource.DataAnnotation));
Assert.Equal(typeof(string), builder.Metadata.ClrType);
Assert.True(builder.ClrType(typeof(int), ConfigurationSource.Explicit));
Assert.Equal(typeof(int), builder.Metadata.ClrType);
}
public void OnEntityTypeAdded_calls_apply_on_conventions_in_order(bool useBuilder)
{
var conventions = new ConventionSet();
InternalEntityTypeBuilder entityTypeBuilder = null;
var convention = new Mock<IEntityTypeConvention>();
convention.Setup(c => c.Apply(It.IsAny<InternalEntityTypeBuilder>())).Returns<InternalEntityTypeBuilder>(b =>
{
Assert.NotNull(b);
entityTypeBuilder = new InternalEntityTypeBuilder(b.Metadata, b.ModelBuilder);
return entityTypeBuilder;
});
conventions.EntityTypeAddedConventions.Add(convention.Object);
var nullConvention = new Mock<IEntityTypeConvention>();
nullConvention.Setup(c => c.Apply(It.IsAny<InternalEntityTypeBuilder>())).Returns<InternalEntityTypeBuilder>(b =>
{
Assert.Same(entityTypeBuilder, b);
return null;
});
conventions.EntityTypeAddedConventions.Add(nullConvention.Object);
var extraConvention = new Mock<IEntityTypeConvention>();
extraConvention.Setup(c => c.Apply(It.IsAny<InternalEntityTypeBuilder>())).Returns<InternalEntityTypeBuilder>(b =>
{
Assert.False(true);
return null;
});
conventions.EntityTypeAddedConventions.Add(extraConvention.Object);
var builder = new InternalModelBuilder(new Model(conventions));
if (useBuilder)
{
Assert.Null(builder.Entity(typeof(Order), ConfigurationSource.Convention));
}
else
{
Assert.Null(builder.Metadata.AddEntityType(typeof(Order), ConfigurationSource.Convention));
}
Assert.NotNull(entityTypeBuilder);
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public virtual InternalModelBuilder Apply(InternalModelBuilder modelBuilder)
{
Check.NotNull(modelBuilder, nameof(modelBuilder));
foreach (var entityType in modelBuilder.Metadata.GetEntityTypes())
{
foreach (var foreignKey in entityType.GetDeclaredForeignKeys())
{
if (foreignKey.IsUnique
&& foreignKey.GetPrincipalEndConfigurationSource() == null)
{
throw new InvalidOperationException(CoreStrings.AmbiguousOneToOneRelationship(
foreignKey.DeclaringEntityType.DisplayName() + (foreignKey.DependentToPrincipal == null ? "" : "." + foreignKey.DependentToPrincipal.Name),
foreignKey.PrincipalEntityType.DisplayName() + (foreignKey.PrincipalToDependent == null ? "" : "." + foreignKey.PrincipalToDependent.Name)));
}
}
}
return modelBuilder;
}
public virtual void Detects_shadow_key_referenced_by_foreign_key_by_convention()
{
var modelBuilder = new InternalModelBuilder(new Model());
var dependentEntityBuilder = modelBuilder.Entity(typeof(SampleEntity), ConfigurationSource.Convention);
dependentEntityBuilder.Property("Id", typeof(int), ConfigurationSource.Convention);
dependentEntityBuilder.PrimaryKey(
new List <string>
{
"Id"
}, ConfigurationSource.Convention);
var principalEntityBuilder = modelBuilder.Entity(typeof(ReferencedEntity), ConfigurationSource.Convention);
principalEntityBuilder.Property("Id", typeof(int), ConfigurationSource.Convention);
principalEntityBuilder.PrimaryKey(
new List <string>
{
"Id"
}, ConfigurationSource.Convention);
dependentEntityBuilder.Property("Foo", typeof(string), ConfigurationSource.Convention);
principalEntityBuilder.Property("ReferencedFoo", typeof(string), ConfigurationSource.Convention);
dependentEntityBuilder.HasForeignKey(
principalEntityBuilder,
dependentEntityBuilder.GetOrCreateProperties(
new List <string>
{
"Foo"
}, ConfigurationSource.Convention),
principalEntityBuilder.HasKey(new[] { "ReferencedFoo" }, ConfigurationSource.Convention).Metadata,
ConfigurationSource.Convention);
VerifyError(
CoreStrings.ReferencedShadowKey(
typeof(SampleEntity).Name,
typeof(ReferencedEntity).Name,
"{'Foo' : string}",
"{'Id' : int}"),
modelBuilder.Metadata);
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public virtual InternalModelBuilder Apply(InternalModelBuilder modelBuilder)
{
var definition = CoreStrings.LogRedundantIndexRemoved;
if (definition.GetLogBehavior(_logger) == WarningBehavior.Ignore &&
!_logger.DiagnosticSource.IsEnabled(definition.EventId.Name))
{
return(modelBuilder);
}
foreach (var entityType in modelBuilder.Metadata.GetEntityTypes())
{
foreach (var declaredForeignKey in entityType.GetDeclaredForeignKeys())
{
foreach (var key in entityType.GetKeys())
{
if (AreIndexedBy(declaredForeignKey.Properties, declaredForeignKey.IsUnique, key.Properties, coveringIndexUniqueness: true))
{
if (declaredForeignKey.Properties.Count != key.Properties.Count)
{
_logger.RedundantIndexRemoved(declaredForeignKey.Properties, key.Properties);
}
}
}
foreach (var existingIndex in entityType.GetIndexes())
{
if (AreIndexedBy(declaredForeignKey.Properties, declaredForeignKey.IsUnique, existingIndex.Properties, existingIndex.IsUnique))
{
if (declaredForeignKey.Properties.Count != existingIndex.Properties.Count)
{
_logger.RedundantIndexRemoved(declaredForeignKey.Properties, existingIndex.Properties);
}
}
}
}
}
return(modelBuilder);
}
public void Can_only_override_lower_source_Required()
{
var modelBuilder = new InternalModelBuilder(new Model(), null);
var customerEntityBuilder = modelBuilder.Entity(typeof(Customer), ConfigurationSource.Explicit);
customerEntityBuilder.Key(new[] { Customer.IdProperty, Customer.UniqueProperty }, ConfigurationSource.Explicit);
var orderEntityBuilder = modelBuilder.Entity(typeof(Order), ConfigurationSource.Explicit);
var relationshipBuilder = orderEntityBuilder.Relationship(typeof(Customer), typeof(Order), null, null, ConfigurationSource.Convention, true, true);
Assert.Null(relationshipBuilder.Metadata.IsRequired);
Assert.False(((IForeignKey)relationshipBuilder.Metadata).IsRequired);
Assert.True(relationshipBuilder.Required(true, ConfigurationSource.Convention));
Assert.True(((IForeignKey)relationshipBuilder.Metadata).IsRequired);
Assert.True(relationshipBuilder.Required(false, ConfigurationSource.DataAnnotation));
Assert.False(((IForeignKey)relationshipBuilder.Metadata).IsRequired);
Assert.False(relationshipBuilder.Required(true, ConfigurationSource.Convention));
Assert.False(((IForeignKey)relationshipBuilder.Metadata).IsRequired);
}
public void IndexAttribute_overrides_configuration_from_convention()
{
var modelBuilder = new InternalModelBuilder(new Model());
var entityBuilder = modelBuilder.Entity(typeof(EntityWithIndex), ConfigurationSource.Convention);
entityBuilder.Property("Id", ConfigurationSource.Convention);
var propABuilder = entityBuilder.Property("A", ConfigurationSource.Convention);
var propBBuilder = entityBuilder.Property("B", ConfigurationSource.Convention);
entityBuilder.PrimaryKey(new List <string> {
"Id"
}, ConfigurationSource.Convention);
var indexProperties = new List <string> {
propABuilder.Metadata.Name, propBBuilder.Metadata.Name
};
var indexBuilder = entityBuilder.HasIndex(indexProperties, "IndexOnAAndB", ConfigurationSource.Convention);
indexBuilder.IsUnique(false, ConfigurationSource.Convention);
indexBuilder.IsDescending(new[] { false, true }, ConfigurationSource.Convention);
RunConvention(entityBuilder);
RunConvention(modelBuilder);
var index = entityBuilder.Metadata.GetIndexes().Single();
Assert.Equal(ConfigurationSource.DataAnnotation, index.GetConfigurationSource());
Assert.Equal("IndexOnAAndB", index.Name);
Assert.True(index.IsUnique);
Assert.Equal(ConfigurationSource.DataAnnotation, index.GetIsUniqueConfigurationSource());
Assert.Equal(new[] { true, false }, index.IsDescending);
Assert.Equal(ConfigurationSource.DataAnnotation, index.GetIsDescendingConfigurationSource());
Assert.Collection(
index.Properties,
prop0 => Assert.Equal("A", prop0.Name),
prop1 => Assert.Equal("B", prop1.Name));
}
public void OnNavigationRemoved_calls_apply_on_conventions_in_order()
{
var conventions = new ConventionSet();
InternalEntityTypeBuilder dependentEntityTypeBuilderFromConvention = null;
InternalEntityTypeBuilder principalEntityBuilderFromConvention = null;
var convention = new Mock <INavigationRemovedConvention>();
convention.Setup(c => c.Apply(It.IsAny <InternalEntityTypeBuilder>(), It.IsAny <InternalEntityTypeBuilder>(), It.IsAny <string>())).Returns((InternalEntityTypeBuilder s, InternalEntityTypeBuilder t, string n) =>
{
dependentEntityTypeBuilderFromConvention = s;
principalEntityBuilderFromConvention = t;
Assert.Equal(nameof(OrderDetails.Order), n);
return(false);
});
conventions.NavigationRemovedConventions.Add(convention.Object);
var extraConvention = new Mock <INavigationRemovedConvention>();
extraConvention.Setup(c => c.Apply(It.IsAny <InternalEntityTypeBuilder>(), It.IsAny <InternalEntityTypeBuilder>(), It.IsAny <string>())).Returns((InternalEntityTypeBuilder s, InternalEntityTypeBuilder t, string n) =>
{
Assert.False(true);
return(false);
});
conventions.NavigationRemovedConventions.Add(extraConvention.Object);
var builder = new InternalModelBuilder(new Model(), conventions);
var principalEntityBuilder = builder.Entity(typeof(Order), ConfigurationSource.Convention);
var dependentEntityBuilder = builder.Entity(typeof(OrderDetails), ConfigurationSource.Convention);
var relationshipBuilder = dependentEntityBuilder.Relationship(principalEntityBuilder, nameof(OrderDetails.Order), nameof(Order.OrderDetails), ConfigurationSource.Convention);
relationshipBuilder.DependentToPrincipal(null, ConfigurationSource.Convention);
Assert.NotNull(relationshipBuilder);
Assert.Same(dependentEntityTypeBuilderFromConvention, dependentEntityBuilder);
Assert.Same(principalEntityBuilderFromConvention, principalEntityBuilder);
}
public void OnModelCreating_VerifyModelCreation()
{
var mockModel = new Mock <ModelBuilder>(new ConventionSet());
try
{
var contextOptions = new DbContextOptions <TaskDbContext>();
var taskModel = new TaskDetail();
var taskDbContextStub = new TaskDbContextStub(contextOptions);
var modelBuilder = new ModelBuilder(new ConventionSet());
// modelBuilder.Entity
var model = new Microsoft.EntityFrameworkCore.Metadata.Internal.Model();
var configSource = new ConfigurationSource();
var entity = new EntityType("TaskModel", model, configSource);
var internalModelBuilder = new InternalModelBuilder(model);
var internalEntityTypeBuilder = new InternalEntityTypeBuilder(entity, internalModelBuilder);
var entityTypeBuilder = new EntityTypeBuilder <TaskDetail>(internalEntityTypeBuilder);
//var entityTypeBuilder = new Mock<EntityTypeBuilder<TaskDetail>>(internalEntityTypeBuilder);
//modelBuilder.Entity<TaskDetail>()
mockModel.Setup(m => m.Entity <TaskDetail>()).Returns(entityTypeBuilder);
var property = new Property("Name", taskModel.GetType(), taskModel.GetType().GetProperty("Name"), taskModel.GetType().GetField("Name"), entity, configSource, null);
var internalPropertyBuilder = new InternalPropertyBuilder(property, internalModelBuilder);
var propertyBuilder = new PropertyBuilder <string>(internalPropertyBuilder);
//mockModel.Setup(m => m.Entity<TaskDetail>()
// mockModel.Setup(m => m.Entity<TaskDetail>().Property("Name")).Returns(propertyBuilder);
taskDbContextStub.TestModelCreation(modelBuilder);
//mockModel.Verify(m => m.Entity<TaskDetail>().HasKey("Id"), Times.Once);
}
catch (Exception ex)
{
mockModel.Verify(m => m.Entity <TaskDetail>().HasKey("Id"), Times.Once);
Assert.NotNull(ex);
}
}
public void ReferencedKey_does_not_return_same_instance_if_no_navigations_or_foreign_key()
{
var modelBuilder = new InternalModelBuilder(new Model(), null);
var customerEntityBuilder = modelBuilder.Entity(typeof(Customer), ConfigurationSource.Explicit);
customerEntityBuilder.Key(new[] { Customer.IdProperty, Customer.UniqueProperty }, ConfigurationSource.Explicit);
var orderEntityBuilder = modelBuilder.Entity(typeof(Order), ConfigurationSource.Explicit);
orderEntityBuilder.Key(new[] { Order.IdProperty }, ConfigurationSource.Explicit);
var relationshipBuilder = orderEntityBuilder.Relationship(typeof(Customer), typeof(Order), null, null, ConfigurationSource.DataAnnotation, true, true)
.ReferencedKey(typeof(Order), new[] { Order.CustomerIdProperty.Name, Order.CustomerUniqueProperty.Name }, ConfigurationSource.DataAnnotation);
Assert.NotNull(relationshipBuilder);
Assert.Same(relationshipBuilder,
relationshipBuilder.ReferencedKey(typeof(Order), new[] { Order.CustomerIdProperty.Name, Order.CustomerUniqueProperty.Name }, ConfigurationSource.DataAnnotation));
Assert.NotSame(relationshipBuilder, customerEntityBuilder.Relationship(typeof(Order), typeof(Customer), null, null, ConfigurationSource.DataAnnotation, true, true)
.ReferencedKey(typeof(Order).FullName, new[] { Order.CustomerIdProperty.Name, Order.CustomerUniqueProperty.Name }, ConfigurationSource.Convention));
Assert.Null(relationshipBuilder.ReferencedKey(typeof(Order), new[] { Order.CustomerIdProperty }, ConfigurationSource.Convention));
Assert.Equal(2, customerEntityBuilder.Metadata.ForeignKeys.Count);
}
public void Can_only_override_existing_ClrType_value_explicitly()
{
var model = new Model();
model.AddEntityType(typeof(Customer)).AddProperty(Customer.NameProperty.Name);
var modelBuilder = new InternalModelBuilder(model);
var entityBuilder = modelBuilder.Entity(typeof(Customer), ConfigurationSource.Explicit);
var builder = entityBuilder.Property(Customer.NameProperty.Name, ConfigurationSource.Convention);
Assert.Null(builder.Metadata.GetClrTypeConfigurationSource());
builder.Metadata.ClrType = typeof(string);
Assert.Equal(ConfigurationSource.Explicit, builder.Metadata.GetClrTypeConfigurationSource());
Assert.True(builder.HasClrType(typeof(string), ConfigurationSource.DataAnnotation));
Assert.False(builder.HasClrType(typeof(int), ConfigurationSource.DataAnnotation));
Assert.Equal(typeof(string), builder.Metadata.ClrType);
Assert.True(builder.HasClrType(typeof(int), ConfigurationSource.Explicit));
Assert.Equal(typeof(int), builder.Metadata.ClrType);
}
public void OnEntityTypeAdded_calls_apply_on_conventions_in_order()
{
var conventions = new ConventionSet();
InternalEntityTypeBuilder entityTypeBuilder = null;
var convention = new Mock <IEntityTypeConvention>();
convention.Setup(c => c.Apply(It.IsAny <InternalEntityTypeBuilder>())).Returns <InternalEntityTypeBuilder>(b =>
{
Assert.NotNull(b);
entityTypeBuilder = new InternalEntityTypeBuilder(b.Metadata, b.ModelBuilder);
return(entityTypeBuilder);
});
conventions.EntityTypeAddedConventions.Add(convention.Object);
var nullConvention = new Mock <IEntityTypeConvention>();
nullConvention.Setup(c => c.Apply(It.IsAny <InternalEntityTypeBuilder>())).Returns <InternalEntityTypeBuilder>(b =>
{
Assert.Same(entityTypeBuilder, b);
return(null);
});
conventions.EntityTypeAddedConventions.Add(nullConvention.Object);
var extraConvention = new Mock <IEntityTypeConvention>();
extraConvention.Setup(c => c.Apply(It.IsAny <InternalEntityTypeBuilder>())).Returns <InternalEntityTypeBuilder>(b =>
{
Assert.False(true);
return(null);
});
conventions.EntityTypeAddedConventions.Add(extraConvention.Object);
var builder = new InternalModelBuilder(new Model(), conventions);
Assert.Null(builder.Entity(typeof(Order), ConfigurationSource.Convention));
Assert.NotNull(entityTypeBuilder);
}
public virtual InternalModelBuilder Apply(InternalModelBuilder modelBuilder)
{
var entityTypes = modelBuilder.Metadata.GetEntityTypes();
foreach (var entityType in entityTypes.Where(et => et.BaseType == null))
{
var currentPrimaryKey = entityType.FindPrimaryKey();
if ((currentPrimaryKey != null) &&
(currentPrimaryKey.Properties.Count > 1))
{
var newKey = entityType.Builder.PrimaryKey(
new List <string> {
currentPrimaryKey.Properties.First().Name
}, ConfigurationSource.DataAnnotation);
if (newKey != null)
{
throw new InvalidOperationException(CoreStrings.CompositePKWithDataAnnotation(entityType.DisplayName()));
}
}
}
return(modelBuilder);
}
public virtual void Detects_dependent_entity_type_with_non_defining_ownership()
{
var modelBuilder = new InternalModelBuilder(new Model());
var entityTypeBuilder = modelBuilder.Entity(typeof(SampleEntity), ConfigurationSource.Convention);
entityTypeBuilder.PrimaryKey(new[] { nameof(SampleEntity.Id) }, ConfigurationSource.Convention);
var ownershipBuilder = entityTypeBuilder.Owns(
typeof(ReferencedEntity), nameof(SampleEntity.ReferencedEntity), ConfigurationSource.Convention);
var ownedTypeBuilder = ownershipBuilder.Metadata.DeclaringEntityType.Builder;
ownedTypeBuilder.PrimaryKey(ownershipBuilder.Metadata.Properties.Select(p => p.Name).ToList(), ConfigurationSource.Convention);
ownedTypeBuilder.Relationship(entityTypeBuilder, (string)null, null, ConfigurationSource.Convention, setTargetAsPrincipal: true)
.IsOwnership(true, ConfigurationSource.Convention);
VerifyError(
CoreStrings.NonDefiningOwnership(
nameof(SampleEntity),
nameof(SampleEntity.ReferencedEntity),
nameof(SampleEntity) + "." + nameof(SampleEntity.ReferencedEntity) + "#" + nameof(ReferencedEntity)),
modelBuilder.Metadata);
}
public override Annotation OnModelAnnotationChanged(
InternalModelBuilder modelBuilder,
string name,
Annotation annotation,
Annotation oldAnnotation)
{
if (modelBuilder.Metadata.Builder == null)
{
return(null);
}
foreach (var modelAnnotationSetConvention in _conventionSet.ModelAnnotationChangedConventions)
{
var newAnnotation = modelAnnotationSetConvention.Apply(modelBuilder, name, annotation, oldAnnotation);
if (newAnnotation != annotation)
{
return(newAnnotation);
}
}
return(annotation);
}
public virtual InternalModelBuilder Apply(InternalModelBuilder modelBuilder)
{
Check.NotNull(modelBuilder, nameof(modelBuilder));
foreach (var entityType in modelBuilder.Metadata.GetEntityTypes())
{
foreach (var foreignKey in entityType.GetDeclaredForeignKeys())
{
if (foreignKey.IsUnique &&
!foreignKey.IsSelfPrimaryKeyReferencing() &&
(foreignKey.GetForeignKeyPropertiesConfigurationSource() == null) &&
(foreignKey.GetPrincipalKeyConfigurationSource() == null))
{
throw new InvalidOperationException(CoreStrings.AmbiguousOneToOneRelationship(
foreignKey.DeclaringEntityType.DisplayName() + (foreignKey.DependentToPrincipal == null ? "" : "." + foreignKey.DependentToPrincipal.Name),
foreignKey.PrincipalEntityType.DisplayName() + (foreignKey.PrincipalToDependent == null ? "" : "." + foreignKey.PrincipalToDependent.Name)));
}
}
}
return(modelBuilder);
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public virtual InternalModelBuilder Apply(InternalModelBuilder modelBuilder)
{
var model = modelBuilder.Metadata;
foreach (var entityType in model.GetEntityTypes())
{
var inverseNavigations = GetInverseNavigations(entityType);
if (inverseNavigations == null)
{
continue;
}
foreach (var inverseNavigation in inverseNavigations)
{
foreach (var referencingNavigationWithAttribute in inverseNavigation.Value)
{
var ambiguousInverse = FindAmbiguousInverse(
referencingNavigationWithAttribute.Item1,
referencingNavigationWithAttribute.Item2,
model,
inverseNavigation.Value);
if (ambiguousInverse != null)
{
_logger.MultipleInversePropertiesSameTargetWarning(
new[]
{
Tuple.Create(referencingNavigationWithAttribute.Item1, referencingNavigationWithAttribute.Item2.ClrType),
Tuple.Create(ambiguousInverse.Value.Item1, ambiguousInverse.Value.Item2.ClrType)
},
inverseNavigation.Key,
entityType.ClrType);
break;
}
}
}
}
return(modelBuilder);
}
public virtual void Detects_non_owner_navigation_to_owned_entity_type()
{
var modelBuilder = new InternalModelBuilder(new Model());
var entityTypeBuilder = modelBuilder.Entity(typeof(SampleEntity), ConfigurationSource.Convention);
entityTypeBuilder.PrimaryKey(new[] { nameof(SampleEntity.Id) }, ConfigurationSource.Convention);
var ownershipBuilder = entityTypeBuilder.Owns(
typeof(ReferencedEntity), nameof(SampleEntity.ReferencedEntity), ConfigurationSource.Convention);
var ownedTypeBuilder = ownershipBuilder.Metadata.DeclaringEntityType.Builder;
ownedTypeBuilder.PrimaryKey(ownershipBuilder.Metadata.Properties.Select(p => p.Name).ToList(), ConfigurationSource.Convention);
var anotherEntityTypeBuilder = modelBuilder.Entity(typeof(AnotherSampleEntity), ConfigurationSource.Convention);
anotherEntityTypeBuilder.PrimaryKey(new[] { nameof(AnotherSampleEntity.Id) }, ConfigurationSource.Convention);
anotherEntityTypeBuilder.Navigation(ownedTypeBuilder, nameof(AnotherSampleEntity.ReferencedEntity), ConfigurationSource.Convention)
.RelatedEntityTypes(anotherEntityTypeBuilder.Metadata, ownedTypeBuilder.Metadata, ConfigurationSource.Convention);
VerifyError(
CoreStrings.InverseToOwnedType(
nameof(AnotherSampleEntity), nameof(SampleEntity.ReferencedEntity), nameof(ReferencedEntity), nameof(SampleEntity)),
modelBuilder.Metadata);
}
public void OnKeyRemoved_calls_apply_on_conventions_in_order()
{
var conventions = new ConventionSet();
InternalKeyBuilder keyBuilder = null;
var convention = new Mock <IKeyRemovedConvention>();
convention.Setup(c => c.Apply(It.IsAny <InternalEntityTypeBuilder>(), It.IsAny <Key>()))
.Callback <InternalEntityTypeBuilder, Key>((b, k) =>
{
Assert.NotNull(b);
Assert.NotNull(k);
keyBuilder = new InternalKeyBuilder(k, b.ModelBuilder);
});
conventions.KeyRemovedConventions.Add(convention.Object);
var extraConvention = new Mock <IKeyRemovedConvention>();
extraConvention.Setup(c => c.Apply(It.IsAny <InternalEntityTypeBuilder>(), It.IsAny <Key>()))
.Callback <InternalEntityTypeBuilder, Key>((b, k) =>
{
Assert.NotNull(b);
Assert.NotNull(k);
Assert.NotNull(keyBuilder);
});
conventions.KeyRemovedConventions.Add(extraConvention.Object);
var builder = new InternalModelBuilder(new Model(conventions));
var entityBuilder = builder.Entity(typeof(Order), ConfigurationSource.Convention);
var key = entityBuilder.HasKey(new List <string> {
"OrderId"
}, ConfigurationSource.Convention).Metadata;
Assert.Same(key, entityBuilder.Metadata.RemoveKey(key.Properties));
Assert.NotNull(keyBuilder);
}
public void OnPropertyAdded_calls_apply_on_conventions_in_order()
{
var conventions = new ConventionSet();
InternalPropertyBuilder propertyBuilder = null;
var convention = new Mock<IPropertyConvention>();
convention.Setup(c => c.Apply(It.IsAny<InternalPropertyBuilder>())).Returns<InternalPropertyBuilder>(b =>
{
Assert.NotNull(b);
propertyBuilder = new InternalPropertyBuilder(b.Metadata, b.ModelBuilder, ConfigurationSource.Convention);
return propertyBuilder;
});
conventions.PropertyAddedConventions.Add(convention.Object);
var nullConvention = new Mock<IPropertyConvention>();
nullConvention.Setup(c => c.Apply(It.IsAny<InternalPropertyBuilder>())).Returns<InternalPropertyBuilder>(b =>
{
Assert.Same(propertyBuilder, b);
return null;
});
conventions.PropertyAddedConventions.Add(nullConvention.Object);
var extraConvention = new Mock<IPropertyConvention>();
extraConvention.Setup(c => c.Apply(It.IsAny<InternalPropertyBuilder>())).Returns<InternalPropertyBuilder>(b =>
{
Assert.False(true);
return null;
});
conventions.PropertyAddedConventions.Add(extraConvention.Object);
var builder = new InternalModelBuilder(new Model(), conventions);
var entityBuilder = builder.Entity(typeof(Order), ConfigurationSource.Convention);
var explicitKeyBuilder = entityBuilder.Property(typeof(int), "OrderId", ConfigurationSource.Convention);
Assert.Null(explicitKeyBuilder);
Assert.NotNull(propertyBuilder);
}
public void Throws_an_exception_when_shadow_key_is_referenced_by_foreign_key()
{
var modelBuilder = new InternalModelBuilder(new Model());
var principalEntityBuilder = modelBuilder.Entity(typeof(SampleEntity), ConfigurationSource.Convention);
var referencedEntityBuilder = modelBuilder.Entity(typeof(ReferencedEntity), ConfigurationSource.Convention);
referencedEntityBuilder.Property("Foo", typeof(string), ConfigurationSource.Convention);
var properties = new List <string> {
"Foo"
};
referencedEntityBuilder.HasForeignKey(
principalEntityBuilder,
referencedEntityBuilder.GetOrCreateProperties(properties, ConfigurationSource.Convention),
ConfigurationSource.Convention);
Assert.Equal(CoreStrings.ReferencedShadowKeyWithoutNavigations(
"{'Foo'}",
typeof(SampleEntity).Name,
"{'Foo'}",
typeof(ReferencedEntity).Name),
Assert.Throws <InvalidOperationException>(() => new KeyConvention().Apply(modelBuilder)).Message);
}
private static InternalModelBuilder BuildModel()
{
var modelBuilder = new InternalModelBuilder(new Model());
var principalType = modelBuilder.Entity(typeof(PrincipalEntity), ConfigurationSource.Explicit);
principalType.PrimaryKey(new[] { nameof(PrincipalEntity.PeeKay) }, ConfigurationSource.Explicit);
var dependentType = modelBuilder.Entity(typeof(DependentEntity), ConfigurationSource.Explicit);
dependentType.PrimaryKey(new[] { nameof(DependentEntity.KayPee) }, ConfigurationSource.Explicit);
var principalTypeWithCompositeKey = modelBuilder.Entity(typeof(PrincipalEntityWithCompositeKey), ConfigurationSource.Explicit);
principalTypeWithCompositeKey.PrimaryKey(new[] { PrincipalEntityWithCompositeKey.IdProperty, PrincipalEntityWithCompositeKey.NameProperty }, ConfigurationSource.Explicit);
principalTypeWithCompositeKey.Property(PrincipalEntityWithCompositeKey.NameProperty, ConfigurationSource.Explicit).IsRequired(true, ConfigurationSource.Explicit);
var dependentTypeWithCompositeKey = modelBuilder.Entity(typeof(DependentEntityWithCompositeKey), ConfigurationSource.Explicit);
dependentTypeWithCompositeKey.PrimaryKey(new[] { nameof(DependentEntityWithCompositeKey.NotId), nameof(DependentEntityWithCompositeKey.NotName) }, ConfigurationSource.Explicit);
return(modelBuilder);
}
public void Does_not_throw_an_exception_when_key_is_referenced_by_foreign_key_and_defined_on_shadow_properties_which_are_not_defined_by_convention()
{
var modelBuilder = new InternalModelBuilder(new Model(), new ConventionSet());
var principalEntityBuilder = modelBuilder.Entity(typeof(SampleEntity), ConfigurationSource.Convention);
var referencedEntityBuilder = modelBuilder.Entity(typeof(ReferencedEntity), ConfigurationSource.Convention);
principalEntityBuilder.Property("Foo", ConfigurationSource.DataAnnotation);
referencedEntityBuilder.Property("Foo", ConfigurationSource.DataAnnotation);
var properties = new List <string> {
"Foo"
};
principalEntityBuilder.Relationship(
principalEntityBuilder,
referencedEntityBuilder,
null,
null,
referencedEntityBuilder.GetOrCreateProperties(properties, ConfigurationSource.Convention),
principalEntityBuilder.GetOrCreateProperties(properties, ConfigurationSource.Convention),
ConfigurationSource.Convention);
Assert.Same(modelBuilder, new KeyConvention().Apply(modelBuilder));
}
public void OnForeignKeyRemoved_calls_apply_on_conventions_in_order()
{
var conventions = new ConventionSet();
var foreignKeyRemoved = false;
var convention = new Mock <IForeignKeyRemovedConvention>();
convention.Setup(c => c.Apply(It.IsAny <InternalEntityTypeBuilder>(), It.IsAny <ForeignKey>())).Callback(() => foreignKeyRemoved = true);
conventions.ForeignKeyRemovedConventions.Add(convention.Object);
var builder = new InternalModelBuilder(new Model(), conventions);
var entityBuilder = builder.Entity(typeof(Order), ConfigurationSource.Convention);
var foreignKey = new ForeignKey(
new[] { entityBuilder.Property(typeof(int), "FK", ConfigurationSource.Convention).Metadata },
entityBuilder.Key(new[] { entityBuilder.Property(typeof(int), "OrderId", ConfigurationSource.Convention).Metadata }, ConfigurationSource.Convention).Metadata);
var conventionDispatcher = new ConventionDispatcher(conventions);
conventionDispatcher.OnForeignKeyRemoved(entityBuilder, foreignKey);
Assert.True(foreignKeyRemoved);
}
private static InternalModelBuilder BuildModel()
{
var modelBuilder = new InternalModelBuilder(new Model(), new ConventionSet());
var principalType = modelBuilder.Entity(typeof(PrincipalEntity), ConfigurationSource.Explicit);
principalType.PrimaryKey(new[] { "PeeKay" }, ConfigurationSource.Explicit);
var dependentType = modelBuilder.Entity(typeof(DependentEntity), ConfigurationSource.Explicit);
dependentType.PrimaryKey(new[] { "KayPee" }, ConfigurationSource.Explicit);
var principalTypeWithCompositeKey = modelBuilder.Entity(typeof(PrincipalEntityWithCompositeKey), ConfigurationSource.Explicit);
principalTypeWithCompositeKey.PrimaryKey(new[] { "Id", "Name" }, ConfigurationSource.Explicit);
principalTypeWithCompositeKey.Property(DependentEntityWithCompositeKey.NameProperty, ConfigurationSource.Explicit).Required(true, ConfigurationSource.Explicit);
var dependentTypeWithCompositeKey = modelBuilder.Entity(typeof(DependentEntityWithCompositeKey), ConfigurationSource.Explicit);
dependentTypeWithCompositeKey.PrimaryKey(new[] { "NotId", "NotName" }, ConfigurationSource.Explicit);
dependentTypeWithCompositeKey.Property(typeof(string), "NotName", ConfigurationSource.Explicit).Required(true, ConfigurationSource.Explicit);
return(modelBuilder);
}
public void OnForeignKeyRemoved_calls_apply_on_conventions_in_order()
{
var conventions = new ConventionSet();
var foreignKeyRemoved = false;
var convention = new Mock <IForeignKeyRemovedConvention>();
convention.Setup(c => c.Apply(It.IsAny <InternalEntityTypeBuilder>(), It.IsAny <ForeignKey>()))
.Callback(() => foreignKeyRemoved = true);
conventions.ForeignKeyRemovedConventions.Add(convention.Object);
var builder = new InternalModelBuilder(new Model(conventions));
var entityBuilder = builder.Entity(typeof(Order), ConfigurationSource.Convention);
var foreignKey = entityBuilder.Metadata.AddForeignKey(
new[] { entityBuilder.Property("FK", typeof(int), ConfigurationSource.Convention).Metadata },
entityBuilder.HasKey(new[] { "OrderId" }, ConfigurationSource.Convention).Metadata,
entityBuilder.Metadata);
Assert.NotNull(entityBuilder.Metadata.RemoveForeignKey(foreignKey.Properties, foreignKey.PrincipalKey, foreignKey.PrincipalEntityType));
Assert.True(foreignKeyRemoved);
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public virtual InternalModelBuilder Apply(InternalModelBuilder modelBuilder)
{
foreach (var entityType in modelBuilder.Metadata.GetEntityTypes())
{
foreach (var declaredNavigation in entityType.GetDeclaredNavigations())
{
if (declaredNavigation.IsCollection())
{
var foreignKey = declaredNavigation.ForeignKey;
var fkPropertyOnPrincipal
= FindForeignKeyAttributeOnProperty(foreignKey.PrincipalEntityType, declaredNavigation.Name);
if (fkPropertyOnPrincipal != null)
{
throw new InvalidOperationException(CoreStrings.FkAttributeOnNonUniquePrincipal(
declaredNavigation.Name,
foreignKey.PrincipalEntityType.DisplayName(),
foreignKey.DeclaringEntityType.DisplayName()));
}
}
}
}
return(modelBuilder);
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public virtual InternalModelBuilder Apply(InternalModelBuilder modelBuilder)
{
foreach (var entityType in modelBuilder.Metadata.GetEntityTypes())
{
foreach (var ignoredMember in entityType.GetIgnoredMembers())
{
var property = entityType.FindProperty(ignoredMember);
if (property != null)
{
if (property.DeclaringEntityType != entityType)
{
throw new InvalidOperationException(
CoreStrings.InheritedPropertyCannotBeIgnored(
ignoredMember, entityType.DisplayName(), property.DeclaringEntityType.DisplayName()));
}
Debug.Assert(false);
}
var navigation = entityType.FindNavigation(ignoredMember);
if (navigation != null)
{
if (navigation.DeclaringEntityType != entityType)
{
throw new InvalidOperationException(
CoreStrings.InheritedPropertyCannotBeIgnored(
ignoredMember, entityType.DisplayName(), navigation.DeclaringEntityType.DisplayName()));
}
Debug.Assert(false);
}
}
}
return(modelBuilder);
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public override bool Apply(
InternalModelBuilder modelBuilder,
Type type,
PropertyInfo navigationPropertyInfo,
Type targetClrType,
InversePropertyAttribute attribute)
{
var declaringType = navigationPropertyInfo.DeclaringType;
Debug.Assert(declaringType != null);
if (modelBuilder.Metadata.FindEntityType(declaringType) != null)
{
return(true);
}
var leastDerivedEntityTypes = modelBuilder.FindLeastDerivedEntityTypes(declaringType,
t => !t.IsIgnored(navigationPropertyInfo.Name, ConfigurationSource.DataAnnotation));
foreach (var leastDerivedEntityType in leastDerivedEntityTypes)
{
Apply(leastDerivedEntityType, navigationPropertyInfo, targetClrType, attribute);
}
return(true);
}
public void Does_not_match_composite_dependent_PK_for_unique_FK_on_derived_type()
{
var modelBuilder = new InternalModelBuilder(new Model());
var principalTypeWithCompositeKey = modelBuilder.Entity(typeof(PrincipalEntityWithCompositeKey), ConfigurationSource.Explicit);
principalTypeWithCompositeKey.PrimaryKey(new[] { PrincipalEntityWithCompositeKey.IdProperty, PrincipalEntityWithCompositeKey.NameProperty }, ConfigurationSource.Explicit);
principalTypeWithCompositeKey.Property(PrincipalEntityWithCompositeKey.NameProperty, ConfigurationSource.Explicit).IsRequired(true, ConfigurationSource.Explicit);
var dependentTypeWithCompositeKeyBase = modelBuilder.Entity(typeof(DependentCompositeBase), ConfigurationSource.Explicit);
var dependentTypeWithCompositeKey = modelBuilder.Entity(typeof(DependentEntityWithCompositeKey), ConfigurationSource.Explicit);
dependentTypeWithCompositeKey.HasBaseType(dependentTypeWithCompositeKeyBase.Metadata, ConfigurationSource.Explicit);
dependentTypeWithCompositeKeyBase.PrimaryKey(new[] { nameof(DependentEntityWithCompositeKey.NotId), nameof(DependentEntityWithCompositeKey.NotName) }, ConfigurationSource.Explicit);
var relationshipBuilder = dependentTypeWithCompositeKey.Relationship(
principalTypeWithCompositeKey,
"NavProp",
"InverseReferenceNav", ConfigurationSource.Convention)
.IsUnique(true, ConfigurationSource.DataAnnotation)
.DependentEntityType(dependentTypeWithCompositeKey, ConfigurationSource.DataAnnotation);
var newRelationshipBuilder = new ForeignKeyPropertyDiscoveryConvention().Apply(relationshipBuilder);
Assert.Same(relationshipBuilder, newRelationshipBuilder);
var fk = (IForeignKey)dependentTypeWithCompositeKey.Metadata.GetForeignKeys().Single();
Assert.Same(fk, newRelationshipBuilder.Metadata);
Assert.NotEqual(dependentTypeWithCompositeKey.Metadata.FindPrimaryKey().Properties[0], fk.Properties[0]);
Assert.NotEqual(dependentTypeWithCompositeKey.Metadata.FindPrimaryKey().Properties[1], fk.Properties[1]);
Assert.Equal("NavProp" + CompositePrimaryKey[0].Name + "1", fk.Properties[0].Name);
Assert.Equal("NavProp" + CompositePrimaryKey[1].Name + "1", fk.Properties[1].Name);
Assert.Same(principalTypeWithCompositeKey.Metadata.FindPrimaryKey(), fk.PrincipalKey);
Assert.True(fk.IsUnique);
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public InternalPropertyBaseBuilder(TPropertyBase metadata, InternalModelBuilder modelBuilder)
: base(metadata, modelBuilder)
{
}
public virtual InternalModelBuilder Apply(InternalModelBuilder modelBuilder)
{
foreach (var entityType in modelBuilder.Metadata.EntityTypes)
{
var entityTypeBuilder = modelBuilder.Entity(entityType.Name, ConfigurationSource.Convention);
foreach (var key in entityType.GetDeclaredKeys())
{
if (key.Properties.Any(p => ((IProperty)p).IsShadowProperty && entityTypeBuilder.CanRemoveProperty(p, ConfigurationSource.Convention)))
{
string message;
var referencingFk = modelBuilder.Metadata.FindReferencingForeignKeys(key).FirstOrDefault();
if (referencingFk != null)
{
message = CoreStrings.ReferencedShadowKey(
Property.Format(key.Properties),
entityType.Name,
Property.Format(key.Properties),
Property.Format(referencingFk.Properties),
referencingFk.DeclaringEntityType.Name);
}
else
{
message = CoreStrings.ShadowKey(
Property.Format(key.Properties),
entityType.Name,
Property.Format(key.Properties));
}
throw new InvalidOperationException(message);
}
}
}
return modelBuilder;
}
private InternalPropertyBuilder CreateInternalPropertyBuilder()
{
var modelBuilder = new InternalModelBuilder(new Model());
var entityBuilder = modelBuilder.Entity(typeof(Customer), ConfigurationSource.Convention);
return entityBuilder.Property(Customer.NameProperty, ConfigurationSource.Convention);
}
public void Does_not_throw_when_clr_type_is_not_set_for_shadow_property()
{
var modelBuilder = new InternalModelBuilder(new Model(), new ConventionSet());
var entityTypeBuilder = modelBuilder.Entity(typeof(NavigationAsProperty), ConfigurationSource.Convention);
entityTypeBuilder.Property("ShadowPropertyOfNullType", ConfigurationSource.Convention);
new PropertyMappingValidationConvention().Apply(modelBuilder);
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public virtual InternalModelBuilder Apply(InternalModelBuilder modelBuilder)
{
foreach (var entityType in modelBuilder.Metadata.GetEntityTypes())
{
if (entityType.ClrType?.IsAbstract == false)
{
var maxServiceParams = 0;
var minPropertyParams = int.MaxValue;
var foundBindings = new List <ConstructorBinding>();
var bindingFailures = new List <IEnumerable <ParameterInfo> >();
foreach (var constructor in entityType.ClrType.GetTypeInfo()
.DeclaredConstructors
.Where(c => !c.IsStatic))
{
// Trying to find the constructor with the most service properties
// followed by the least scalar property parameters
if (_bindingFactory.TryBindConstructor(entityType, constructor, out var binding, out var failures))
{
var serviceParamCount = binding.ParameterBindings.OfType <ServiceParameterBinding>().Count();
var propertyParamCount = binding.ParameterBindings.Count - serviceParamCount;
if (serviceParamCount == maxServiceParams &&
propertyParamCount == minPropertyParams)
{
foundBindings.Add(binding);
}
else if (serviceParamCount > maxServiceParams)
{
foundBindings.Clear();
foundBindings.Add(binding);
maxServiceParams = serviceParamCount;
minPropertyParams = propertyParamCount;
}
else if (propertyParamCount < minPropertyParams)
{
foundBindings.Clear();
foundBindings.Add(binding);
maxServiceParams = serviceParamCount;
minPropertyParams = propertyParamCount;
}
}
else
{
bindingFailures.Add(failures);
}
}
if (foundBindings.Count == 0)
{
var constructorErrors = bindingFailures.SelectMany(f => f)
.GroupBy(f => f.Member as ConstructorInfo)
.Select(
x =>
CoreStrings.ConstructorBindingFailed(
string.Join("', '", x.Select(f => f.Name)),
entityType.DisplayName() + "(" +
string.Join(
", ", x.Key.GetParameters().Select(
y =>
y.ParameterType.ShortDisplayName() + " " + y.Name)
) +
")"
)
);
throw new InvalidOperationException(
CoreStrings.ConstructorNotFound(
entityType.DisplayName(),
string.Join("; ", constructorErrors)));
}
if (foundBindings.Count > 1)
{
throw new InvalidOperationException(
CoreStrings.ConstructorConflict(
FormatConstructorString(entityType, foundBindings[0]),
FormatConstructorString(entityType, foundBindings[1])));
}
entityType.Builder.HasAnnotation(
CoreAnnotationNames.ConstructorBinding,
foundBindings[0],
ConfigurationSource.Convention);
}
public BlazorComponentColumnCollection(IGridConfigurationProvider gridConfigurationProvider)
{
this.gridConfigurationProvider = gridConfigurationProvider ?? throw new ArgumentNullException(nameof(gridConfigurationProvider));
this.internalModelBuilder = new InternalModelBuilder(gridConfigurationProvider.ConfigurationModel as Model);
}
protected internal ModelBuilder([NotNull] InternalModelBuilder internalBuilder)
{
Check.NotNull(internalBuilder, "internalBuilder");
_builder = internalBuilder;
}
public void Does_not_throw_when_non_candidate_property_is_not_added()
{
var modelBuilder = new InternalModelBuilder(new Model(), new ConventionSet());
var entityTypeBuilder = modelBuilder.Entity(typeof(NonCandidatePropertyEntity), ConfigurationSource.Convention);
new PropertyMappingValidationConvention().Apply(modelBuilder);
}
