Add skip navigation support in Metadata

Part of #19003

src/EFCore/Extensions/ConventionNavigationExtensions.cs

@@ -22,7 +22,7 @@ public static class ConventionNavigationExtensions
         ///     The inverse navigation, or <c>null</c> if none is defined.
         /// </returns>
         public static IConventionNavigation FindInverse([NotNull] this IConventionNavigation navigation)
-            => (IConventionNavigation)((INavigation)navigation).FindInverse();
+            => ((Navigation)navigation).FindInverse();
 
         /// <summary>
         ///     Gets the entity type that a given navigation property will hold an instance of
@@ -31,7 +31,7 @@ public static IConventionNavigation FindInverse([NotNull] this IConventionNaviga
         /// <param name="navigation"> The navigation property to find the target entity type of. </param>
         /// <returns> The target entity type. </returns>
         public static IConventionEntityType GetTargetType([NotNull] this IConventionNavigation navigation)
-            => (IConventionEntityType)((INavigation)navigation).GetTargetType();
+            => ((Navigation)navigation).GetTargetType();
 
         /// <summary>
         ///     Sets a value indicating whether this navigation should be eager loaded by default.

src/EFCore/Extensions/EntityTypeExtensions.cs

@@ -397,7 +397,7 @@ public static IKey FindKey([NotNull] this IEntityType entityType, [NotNull] IPro
         /// <param name="property"> The property to find the foreign keys on. </param>
         /// <returns> The foreign keys. </returns>
         public static IEnumerable<IForeignKey> FindForeignKeys([NotNull] this IEntityType entityType, [NotNull] IProperty property)
-            => entityType.FindForeignKeys(new[] { property });
+            => property.GetContainingForeignKeys();
 
         /// <summary>
         ///     Gets the foreign keys defined on the given properties. Only foreign keys that are defined on exactly the specified
@@ -413,13 +413,8 @@ public static IEnumerable<IForeignKey> FindForeignKeys(
             Check.NotEmpty(properties, nameof(properties));
             Check.HasNoNulls(properties, nameof(properties));
 
-            foreach (var foreignKey in entityType.GetForeignKeys())
-            {
-                if (PropertyListComparer.Instance.Equals(foreignKey.Properties, properties))
-                {
-                    yield return foreignKey;
-                }
-            }
+            return entityType.GetForeignKeys()
+                .Where(foreignKey => PropertyListComparer.Instance.Equals(foreignKey.Properties, properties));
         }
 
         /// <summary>

src/EFCore/Extensions/MutableNavigationExtensions.cs

@@ -22,7 +22,7 @@ public static class MutableNavigationExtensions
         ///     The inverse navigation, or <c>null</c> if none is defined.
         /// </returns>
         public static IMutableNavigation FindInverse([NotNull] this IMutableNavigation navigation)
-            => (IMutableNavigation)((INavigation)navigation).FindInverse();
+            => ((Navigation)navigation).FindInverse();
 
         /// <summary>
         ///     Gets the entity type that a given navigation property will hold an instance of
@@ -31,7 +31,7 @@ public static IMutableNavigation FindInverse([NotNull] this IMutableNavigation n
         /// <param name="navigation"> The navigation property to find the target entity type of. </param>
         /// <returns> The target entity type. </returns>
         public static IMutableEntityType GetTargetType([NotNull] this IMutableNavigation navigation)
-            => (IMutableEntityType)((INavigation)navigation).GetTargetType();
+            => ((Navigation)navigation).GetTargetType();
 
         /// <summary>
         ///     Sets a value indicating whether this navigation should be eager loaded by default.

src/EFCore/Extensions/NavigationExtensions.cs

@@ -62,13 +62,7 @@ public static bool IsCollection([NotNull] this INavigation navigation)
         /// </returns>
         [DebuggerStepThrough]
         public static INavigation FindInverse([NotNull] this INavigation navigation)
-        {
-            Check.NotNull(navigation, nameof(navigation));
-
-            return navigation.IsDependentToPrincipal()
-                ? navigation.ForeignKey.PrincipalToDependent
-                : navigation.ForeignKey.DependentToPrincipal;
-        }
+            => ((Navigation)Check.NotNull(navigation, nameof(navigation))).FindInverse();
 
         /// <summary>
         ///     Gets the entity type that a given navigation property will hold an instance of
@@ -78,13 +72,7 @@ public static INavigation FindInverse([NotNull] this INavigation navigation)
         /// <returns> The target entity type. </returns>
         [DebuggerStepThrough]
         public static IEntityType GetTargetType([NotNull] this INavigation navigation)
-        {
-            Check.NotNull(navigation, nameof(navigation));
-
-            return navigation.IsDependentToPrincipal()
-                ? navigation.ForeignKey.PrincipalEntityType
-                : navigation.ForeignKey.DeclaringEntityType;
-        }
+            => (Check.NotNull(navigation, nameof(navigation)) as Navigation)?.GetTargetType();
 
         /// <summary>
         ///     Gets a value indicating whether this navigation should be eager loaded by default.

src/EFCore/Infrastructure/ModelValidator.cs

@@ -107,6 +107,21 @@ protected virtual void ValidateRelationships(
                                     : "." + foreignKey.PrincipalToDependent.Name)));
                     }
                 }
+
+                foreach (var navigation in entityType.GetDeclaredSkipNavigations())
+                {
+                    if (!navigation.IsCollection)
+                    {
+                        throw new InvalidOperationException(CoreStrings.SkipNavigationNonCollection(
+                            navigation.Name, navigation.DeclaringEntityType.DisplayName()));
+                    }
+
+                    if (navigation.Inverse == null)
+                    {
+                        throw new InvalidOperationException(CoreStrings.SkipNavigationNoInverse(
+                            navigation.Name, navigation.DeclaringEntityType.DisplayName()));
+                    }
+                }
             }
         }
 
@@ -155,6 +170,7 @@ protected virtual void ValidatePropertyMapping(
 
                 clrProperties.ExceptWith(entityType.GetProperties().Select(p => p.Name));
                 clrProperties.ExceptWith(entityType.GetNavigations().Select(p => p.Name));
+                clrProperties.ExceptWith(entityType.GetSkipNavigations().Select(p => p.Name));
                 clrProperties.ExceptWith(entityType.GetServiceProperties().Select(p => p.Name));
                 clrProperties.RemoveWhere(p => entityType.FindIgnoredConfigurationSource(p) != null);
 

src/EFCore/Metadata/Builders/IConventionSkipNavigationBuilder.cs

@@ -0,0 +1,22 @@
+// 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.
+
+namespace Microsoft.EntityFrameworkCore.Metadata.Builders
+{
+    /// <summary>
+    ///     <para>
+    ///         Provides a simple API surface for configuring an <see cref="IConventionSkipNavigation" /> from conventions.
+    ///     </para>
+    ///     <para>
+    ///         This interface is typically used by database providers (and other extensions). It is generally
+    ///         not used in application code.
+    ///     </para>
+    /// </summary>
+    public interface IConventionSkipNavigationBuilder : IConventionAnnotatableBuilder
+    {
+        /// <summary>
+        ///     The navigation property being configured.
+        /// </summary>
+        new IConventionSkipNavigation Metadata { get; }
+    }
+}

src/EFCore/Metadata/Conventions/ConventionSet.cs

@@ -121,11 +121,41 @@ public class ConventionSet
         /// </summary>
         public virtual IList<INavigationAddedConvention> NavigationAddedConventions { get; } = new List<INavigationAddedConvention>();
 
+        /// <summary>
+        ///     Conventions to run when an annotation is changed on a navigation property.
+        /// </summary>
+        public virtual IList<INavigationAnnotationChangedConvention> NavigationAnnotationChangedConventions { get; }
+            = new List<INavigationAnnotationChangedConvention>();        
+
         /// <summary>
         ///     Conventions to run when a navigation property is removed.
         /// </summary>
         public virtual IList<INavigationRemovedConvention> NavigationRemovedConventions { get; } = new List<INavigationRemovedConvention>();
 
+        /// <summary>
+        ///     Conventions to run when a skip navigation property is added.
+        /// </summary>
+        public virtual IList<ISkipNavigationAddedConvention> SkipNavigationAddedConventions { get; }
+            = new List<ISkipNavigationAddedConvention>();
+
+        /// <summary>
+        ///     Conventions to run when an annotation is changed on a skip navigation property.
+        /// </summary>
+        public virtual IList<ISkipNavigationAnnotationChangedConvention> SkipNavigationAnnotationChangedConventions { get; }
+            = new List<ISkipNavigationAnnotationChangedConvention>();
+
+        /// <summary>
+        ///     Conventions to run when a skip navigation inverse is changed.
+        /// </summary>
+        public virtual IList<ISkipNavigationInverseChangedConvention> SkipNavigationInverseChangedConventions { get; }
+            = new List<ISkipNavigationInverseChangedConvention>();
+
+        /// <summary>
+        ///     Conventions to run when a skip navigation property is removed.
+        /// </summary>
+        public virtual IList<ISkipNavigationRemovedConvention> SkipNavigationRemovedConventions { get; }
+            = new List<ISkipNavigationRemovedConvention>();
+
         /// <summary>
         ///     Conventions to run when a key is added.
         /// </summary>
@@ -187,6 +217,11 @@ public class ConventionSet
         public virtual IList<IPropertyAnnotationChangedConvention> PropertyAnnotationChangedConventions { get; }
             = new List<IPropertyAnnotationChangedConvention>();
 
+        /// <summary>
+        ///     Conventions to run when a property is removed.
+        /// </summary>
+        public virtual IList<IPropertyRemovedConvention> PropertyRemovedConventions { get; } = new List<IPropertyRemovedConvention>();
+
         /// <summary>
         ///     Replaces an existing convention with a derived convention.
         /// </summary>

src/EFCore/Metadata/Conventions/INavigationAnnotationChangedConvention.cs

@@ -0,0 +1,31 @@
+// 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 JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Microsoft.EntityFrameworkCore.Metadata.Conventions
+{
+    /// <summary>
+    ///     Represents an operation that should be performed when an annotation is changed on a navigation.
+    /// </summary>
+    public interface INavigationAnnotationChangedConvention : IConvention
+    {
+        /// <summary>
+        ///     Called after an annotation is changed on a navigation.
+        /// </summary>
+        /// <param name="relationshipBuilder"> The builder for the foreign key. </param>
+        /// <param name="navigation"> The navigation. </param>
+        /// <param name="name"> The annotation name. </param>
+        /// <param name="annotation"> The new annotation. </param>
+        /// <param name="oldAnnotation"> The old annotation.  </param>
+        /// <param name="context"> Additional information associated with convention execution. </param>
+        void ProcessNavigationAnnotationChanged(
+            [NotNull] IConventionRelationshipBuilder relationshipBuilder,
+            [NotNull] IConventionNavigation navigation,
+            [NotNull] string name,
+            [CanBeNull] IConventionAnnotation annotation,
+            [CanBeNull] IConventionAnnotation oldAnnotation,
+            [NotNull] IConventionContext<IConventionAnnotation> context);
+    }
+}

src/EFCore/Metadata/Conventions/IPropertyRemovedConvention.cs

@@ -0,0 +1,25 @@
+// 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 JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Microsoft.EntityFrameworkCore.Metadata.Conventions
+{
+    /// <summary>
+    ///     Represents an operation that should be performed when a property is removed from the entity type.
+    /// </summary>
+    public interface IPropertyRemovedConvention : IConvention
+    {
+        /// <summary>
+        ///     Called after a property is removed from the entity type.
+        /// </summary>
+        /// <param name="entityTypeBuilder"> The builder for the entity type that contained the property. </param>
+        /// <param name="property"> The removed property. </param>
+        /// <param name="context"> Additional information associated with convention execution. </param>
+        void ProcessPropertyRemoved(
+            [NotNull] IConventionEntityTypeBuilder entityTypeBuilder,
+            [NotNull] IConventionProperty property,
+            [NotNull] IConventionContext<IConventionProperty> context);
+    }
+}

src/EFCore/Metadata/Conventions/ISkipNavigationAddedConvention.cs

@@ -0,0 +1,23 @@
+// 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 JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Microsoft.EntityFrameworkCore.Metadata.Conventions
+{
+    /// <summary>
+    ///     Represents an operation that should be performed when a skip navigation is added to the entity type.
+    /// </summary>
+    public interface ISkipNavigationAddedConvention : IConvention
+    {
+        /// <summary>
+        ///     Called after a skip navigation is added to the entity type.
+        /// </summary>
+        /// <param name="skipNavigationBuilder"> The builder for the skip navigation. </param>
+        /// <param name="context"> Additional information associated with convention execution. </param>
+        void ProcessSkipNavigationAdded(
+            [NotNull] IConventionSkipNavigationBuilder skipNavigationBuilder,
+            [NotNull] IConventionContext<IConventionSkipNavigationBuilder> context);
+    }
+}

src/EFCore/Metadata/Conventions/ISkipNavigationAnnotationChangedConvention.cs

@@ -0,0 +1,29 @@
+// 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 JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Microsoft.EntityFrameworkCore.Metadata.Conventions
+{
+    /// <summary>
+    ///     Represents an operation that should be performed when an annotation is changed on a skip navigation.
+    /// </summary>
+    public interface ISkipNavigationAnnotationChangedConvention : IConvention
+    {
+        /// <summary>
+        ///     Called after an annotation is changed on a skip navigation.
+        /// </summary>
+        /// <param name="skipNavigationBuilder"> The builder for the skip navigation. </param>
+        /// <param name="name"> The annotation name. </param>
+        /// <param name="annotation"> The new annotation. </param>
+        /// <param name="oldAnnotation"> The old annotation.  </param>
+        /// <param name="context"> Additional information associated with convention execution. </param>
+        void ProcessSkipNavigationAnnotationChanged(
+            [NotNull] IConventionSkipNavigationBuilder skipNavigationBuilder,
+            [NotNull] string name,
+            [CanBeNull] IConventionAnnotation annotation,
+            [CanBeNull] IConventionAnnotation oldAnnotation,
+            [NotNull] IConventionContext<IConventionAnnotation> context);
+    }
+}

src/EFCore/Metadata/Conventions/ISkipNavigationInverseChangedConvention.cs

@@ -0,0 +1,27 @@
+// 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 JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Microsoft.EntityFrameworkCore.Metadata.Conventions
+{
+    /// <summary>
+    ///     Represents an operation that should be performed when a skip navigation inverse is changed.
+    /// </summary>
+    public interface ISkipNavigationInverseChangedConvention : IConvention
+    {
+        /// <summary>
+        ///     Called after a skip navigation inverse is changed.
+        /// </summary>
+        /// <param name="skipNavigationBuilder"> The builder for the skip navigation. </param>
+        /// <param name="inverse"> The current inverse skip navigation. </param>
+        /// <param name="oldInverse"> The old inverse skip navigation. </param>
+        /// <param name="context"> Additional information associated with convention execution. </param>
+        void ProcessSkipNavigationInverseChanged(
+            [NotNull] IConventionSkipNavigationBuilder skipNavigationBuilder,
+            [NotNull] IConventionSkipNavigation inverse,
+            [NotNull] IConventionSkipNavigation oldInverse,
+            [NotNull] IConventionContext<IConventionSkipNavigation> context);
+    }
+}

src/EFCore/Metadata/Conventions/ISkipNavigationRemovedConvention.cs

@@ -0,0 +1,25 @@
+// 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 JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Microsoft.EntityFrameworkCore.Metadata.Conventions
+{
+    /// <summary>
+    ///     Represents an operation that should be performed when a skip navigation is removed from the entity type.
+    /// </summary>
+    public interface ISkipNavigationRemovedConvention : IConvention
+    {
+        /// <summary>
+        ///     Called after a skip navigation is removed from the entity type.
+        /// </summary>
+        /// <param name="entityTypeBuilder"> The builder for the entity type that contained the navigation. </param>
+        /// <param name="navigation"> The removed navigation. </param>
+        /// <param name="context"> Additional information associated with convention execution. </param>
+        void ProcessSkipNavigationRemoved(
+            [NotNull] IConventionEntityTypeBuilder entityTypeBuilder,
+            [NotNull] IConventionSkipNavigation navigation,
+            [NotNull] IConventionContext<IConventionSkipNavigation> context);
+    }
+}