Throw when an inherited property or navigation is ignored

Fixes #5864
dotnet · Jul 31, 2016 · d972f6d · d972f6d
1 parent a8c05dd
commit d972f6d
Show file tree

Hide file tree

Showing 17 changed files with 612 additions and 226 deletions.
diff --git a/...yFrameworkCore.Relational/Metadata/Conventions/Internal/RelationalConventionSetBuilder.cs b/...yFrameworkCore.Relational/Metadata/Conventions/Internal/RelationalConventionSetBuilder.cs
@@ -54,6 +54,7 @@ public virtual ConventionSet AddConventions(ConventionSet conventionSet)
             ReplaceConvention(conventionSet.BaseEntityTypeSetConventions, inversePropertyAttributeConvention);
             ReplaceConvention(conventionSet.BaseEntityTypeSetConventions, relationshipDiscoveryConvention);
 
+            ReplaceConvention(conventionSet.EntityTypeMemberIgnoredConventions, inversePropertyAttributeConvention);
             ReplaceConvention(conventionSet.EntityTypeMemberIgnoredConventions, relationshipDiscoveryConvention);
 
             ReplaceConvention(conventionSet.ForeignKeyAddedConventions, (ForeignKeyAttributeConvention)new RelationalForeignKeyAttributeConvention(_typeMapper));

diff --git a/src/Microsoft.EntityFrameworkCore.Specification.Tests/DataAnnotationTestBase.cs b/src/Microsoft.EntityFrameworkCore.Specification.Tests/DataAnnotationTestBase.cs
diff --git a/src/Microsoft.EntityFrameworkCore/Metadata/Conventions/Internal/ConventionDispatcher.cs b/src/Microsoft.EntityFrameworkCore/Metadata/Conventions/Internal/ConventionDispatcher.cs
@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using System.Diagnostics;
 using System.Reflection;
 using JetBrains.Annotations;
 using Microsoft.EntityFrameworkCore.Metadata.Internal;
@@ -130,6 +131,7 @@ public virtual InternalRelationshipBuilder OnForeignKeyAdded([NotNull] InternalR
                 {
                     break;
                 }
+                Debug.Assert(relationshipBuilder.Metadata.Builder == relationshipBuilder);
             }
 
             return relationshipBuilder;

diff --git a/src/Microsoft.EntityFrameworkCore/Metadata/Conventions/Internal/CoreConventionSetBuilder.cs b/src/Microsoft.EntityFrameworkCore/Metadata/Conventions/Internal/CoreConventionSetBuilder.cs
@@ -38,6 +38,7 @@ public virtual ConventionSet CreateConventionSet()
             conventionSet.BaseEntityTypeSetConventions.Add(relationshipDiscoveryConvention);
 
             // An ambiguity might have been resolved
+            conventionSet.EntityTypeMemberIgnoredConventions.Add(inversePropertyAttributeConvention);
             conventionSet.EntityTypeMemberIgnoredConventions.Add(relationshipDiscoveryConvention);
 
             var keyAttributeConvention = new KeyAttributeConvention();
@@ -69,6 +70,7 @@ public virtual ConventionSet CreateConventionSet()
             conventionSet.ModelBuiltConventions.Add(new ModelCleanupConvention());
             conventionSet.ModelBuiltConventions.Add(keyAttributeConvention);
             conventionSet.ModelBuiltConventions.Add(keyConvention);
+            conventionSet.ModelBuiltConventions.Add(new IgnoredMembersValidationConvention());
             conventionSet.ModelBuiltConventions.Add(new PropertyMappingValidationConvention());
             conventionSet.ModelBuiltConventions.Add(new RelationshipValidationConvention());
 

diff --git a/...ntityFrameworkCore/Metadata/Conventions/Internal/ForeignKeyPropertyDiscoveryConvention.cs b/...ntityFrameworkCore/Metadata/Conventions/Internal/ForeignKeyPropertyDiscoveryConvention.cs
@@ -35,7 +35,12 @@ public virtual InternalRelationshipBuilder Apply(InternalRelationshipBuilder rel
                         var invertedRelationshipBuilder = relationshipBuilder
                             .RelatedEntityTypes(foreignKey.DeclaringEntityType, foreignKey.PrincipalEntityType, ConfigurationSource.Convention);
 
-                        return invertedRelationshipBuilder ?? relationshipBuilder;
+                        if (invertedRelationshipBuilder != null)
+                        {
+                            return invertedRelationshipBuilder;
+                        }
+
+                        return foreignKey.Builder == null ? null : relationshipBuilder;
                     }
                 }
 

diff --git a/...t.EntityFrameworkCore/Metadata/Conventions/Internal/IgnoredMembersValidationConvention.cs b/...t.EntityFrameworkCore/Metadata/Conventions/Internal/IgnoredMembersValidationConvention.cs
@@ -0,0 +1,54 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Diagnostics;
+using Microsoft.EntityFrameworkCore.Internal;
+using Microsoft.EntityFrameworkCore.Metadata.Internal;
+
+namespace Microsoft.EntityFrameworkCore.Metadata.Conventions.Internal
+{
+    /// <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 class IgnoredMembersValidationConvention : IModelConvention
+    {
+        /// <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 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;
+        }
+    }
+}
diff --git a/...t.EntityFrameworkCore/Metadata/Conventions/Internal/InversePropertyAttributeConvention.cs b/...t.EntityFrameworkCore/Metadata/Conventions/Internal/InversePropertyAttributeConvention.cs
@@ -86,8 +86,8 @@ public class InversePropertyAttributeConvention : NavigationAttributeEntityTypeC
 
             // Check for InversePropertyAttribute on the inverseNavigation to verify that it matches.
             var inverseAttribute = inverseNavigationPropertyInfo.GetCustomAttribute<InversePropertyAttribute>(true);
-            if ((inverseAttribute != null)
-                && (inverseAttribute.Property != navigationPropertyInfo.Name))
+            if (inverseAttribute != null
+                && inverseAttribute.Property != navigationPropertyInfo.Name)
             {
                 throw new InvalidOperationException(
                     CoreStrings.InversePropertyMismatch(
@@ -120,7 +120,10 @@ public class InversePropertyAttributeConvention : NavigationAttributeEntityTypeC
                         inverseNavigationsList))
                 {
                     var fk = existingInverse.ForeignKey;
-                    fk.DeclaringEntityType.Builder.RemoveForeignKey(fk, ConfigurationSource.DataAnnotation);
+                    if (fk.GetConfigurationSource() == ConfigurationSource.DataAnnotation)
+                    {
+                        fk.DeclaringEntityType.Builder.RemoveForeignKey(fk, ConfigurationSource.DataAnnotation);
+                    }
                 }
 
                 return null;
@@ -202,6 +205,67 @@ public class InversePropertyAttributeConvention : NavigationAttributeEntityTypeC
             return true;
         }
 
+        /// <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 ApplyIgnored(
+            InternalEntityTypeBuilder entityTypeBuilder,
+            PropertyInfo navigationPropertyInfo,
+            Type targetClrType,
+            InversePropertyAttribute attribute)
+        {
+            var entityType = entityTypeBuilder.Metadata;
+            var targetType = entityType.Model.FindEntityType(targetClrType);
+            var inverseNavigationPropertyInfo = targetClrType.GetRuntimeProperties()
+                .FirstOrDefault(p => string.Equals(p.Name, attribute.Property, StringComparison.OrdinalIgnoreCase));
+            if (targetType == null
+                || inverseNavigationPropertyInfo == null)
+            {
+                return true;
+            }
+
+            List<Tuple<PropertyInfo, Type>> navigationTuples;
+            var inverseNavigations = GetInverseNavigations(targetType);
+            if (inverseNavigations == null
+                || !inverseNavigations.TryGetValue(inverseNavigationPropertyInfo, out navigationTuples))
+            {
+                return true;
+            }
+
+            var inverseWasAmbiguous = false;
+            for (var index = 0; index < navigationTuples.Count; index++)
+            {
+                var inverseTuple = navigationTuples[index];
+                if (inverseTuple.Item1 == navigationPropertyInfo
+                    && inverseTuple.Item2 == entityType.ClrType)
+                {
+                    navigationTuples.RemoveAt(index);
+                    if (!navigationTuples.Any())
+                    {
+                        inverseNavigations.Remove(inverseNavigationPropertyInfo);
+                    }
+                    inverseWasAmbiguous = true;
+                    break;
+                }
+            }
+
+            if (!inverseWasAmbiguous
+                || navigationTuples.Count > 1)
+            {
+                return true;
+            }
+
+            var otherEntityTypeBuilder = entityTypeBuilder.ModelBuilder.Entity(navigationTuples[0].Item2, ConfigurationSource.DataAnnotation);
+            targetType.Builder.Relationship(
+                otherEntityTypeBuilder,
+                inverseNavigationPropertyInfo,
+                navigationTuples[0].Item1,
+                ConfigurationSource.DataAnnotation);
+
+            return true;
+        }
+
         private static bool IsAmbiguousInverse(
             PropertyInfo navigationPropertyInfo, EntityType entityType, List<Tuple<PropertyInfo, Type>> inverseNavigationsList)
         {

diff --git a/...ityFrameworkCore/Metadata/Conventions/Internal/NavigationAttributeEntityTypeConvention.cs b/...ityFrameworkCore/Metadata/Conventions/Internal/NavigationAttributeEntityTypeConvention.cs
@@ -14,7 +14,7 @@ namespace Microsoft.EntityFrameworkCore.Metadata.Conventions.Internal
     ///     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 abstract class NavigationAttributeEntityTypeConvention<TAttribute> : IEntityTypeConvention, IEntityTypeIgnoredConvention, INavigationConvention, IBaseTypeConvention
+    public abstract class NavigationAttributeEntityTypeConvention<TAttribute> : IEntityTypeConvention, IEntityTypeIgnoredConvention, INavigationConvention, IBaseTypeConvention, IEntityTypeMemberIgnoredConvention
         where TAttribute : Attribute
     {
         /// <summary>
@@ -152,6 +152,39 @@ public virtual bool Apply(InternalEntityTypeBuilder entityTypeBuilder, EntityTyp
             return true;
         }
 
+        /// <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 bool Apply(InternalEntityTypeBuilder entityTypeBuilder, string ignoredMemberName)
+        {
+            var navigationPropertyInfo =
+                entityTypeBuilder.Metadata.ClrType.GetRuntimeProperties().FirstOrDefault(p => p.Name == ignoredMemberName);
+            if (navigationPropertyInfo == null)
+            {
+                return true;
+            }
+
+            var targetClrType = FindCandidateNavigationPropertyType(navigationPropertyInfo);
+            if (targetClrType == null)
+            {
+                return true;
+            }
+
+            var attributes = navigationPropertyInfo.GetCustomAttributes<TAttribute>(true);
+            if (attributes != null)
+            {
+                foreach (var attribute in attributes)
+                {
+                    if (!ApplyIgnored(entityTypeBuilder, navigationPropertyInfo, targetClrType, attribute))
+                    {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
+
         /// <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.
@@ -215,5 +248,18 @@ public virtual Type FindCandidateNavigationPropertyType([NotNull] PropertyInfo p
         {
             throw new NotImplementedException();
         }
+
+        /// <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 bool ApplyIgnored(
+            [NotNull] InternalEntityTypeBuilder entityTypeBuilder,
+            [NotNull] PropertyInfo navigationPropertyInfo,
+            [NotNull] Type targetClrType,
+            [NotNull] TAttribute attribute)
+        {
+            throw new NotImplementedException();
+        }
     }
 }
diff --git a/src/Microsoft.EntityFrameworkCore/Metadata/Internal/EntityType.cs b/src/Microsoft.EntityFrameworkCore/Metadata/Internal/EntityType.cs
@@ -1656,7 +1656,8 @@ public virtual Func<ISnapshot> EmptyShadowValuesFactory
         ///     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 void Ignore([NotNull] string name, ConfigurationSource configurationSource = ConfigurationSource.Explicit)
+        public virtual void Ignore([NotNull] string name, ConfigurationSource configurationSource = ConfigurationSource.Explicit,
+            bool runConventions = true)
         {
             Check.NotNull(name, nameof(name));
 
@@ -1668,14 +1669,24 @@ public virtual void Ignore([NotNull] string name, ConfigurationSource configurat
 
             _ignoredMembers[name] = configurationSource;
 
-            Model.ConventionDispatcher.OnEntityTypeMemberIgnored(Builder, name);
+            if (runConventions)
+            {
+                Model.ConventionDispatcher.OnEntityTypeMemberIgnored(Builder, name);
+            }
         }
 
+        /// <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 IReadOnlyList<string> GetIgnoredMembers()
+            => _ignoredMembers.Keys.ToList();
+
         /// <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 ConfigurationSource? FindIgnoredMemberConfigurationSource([NotNull] string name)
+        public virtual ConfigurationSource? FindDeclaredIgnoredMemberConfigurationSource([NotNull] string name)
         {
             Check.NotEmpty(name, nameof(name));
 
@@ -1688,6 +1699,17 @@ public virtual void Ignore([NotNull] string name, ConfigurationSource configurat
             return null;
         }
 
+        /// <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 ConfigurationSource? FindIgnoredMemberConfigurationSource([NotNull] string name)
+        {
+            var ignoredSource = FindDeclaredIgnoredMemberConfigurationSource(name);
+
+            return BaseType == null ? ignoredSource : BaseType.FindIgnoredMemberConfigurationSource(name).Max(ignoredSource);
+        }
+
         /// <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.