Avoid reduntant looping in property metadata

AndriySvyryd · AndriySvyryd · commit bc1fdcc06618 · 2022-12-15T12:13:42.000-08:00
Fixes #29642
diff --git a/src/EFCore.Design/Scaffolding/Internal/CSharpRuntimeModelCodeGenerator.cs b/src/EFCore.Design/Scaffolding/Internal/CSharpRuntimeModelCodeGenerator.cs
@@ -849,41 +849,53 @@ private void Create(
 
     private static Type? GetValueConverterType(IProperty property)
     {
-        var type = (Type?)property[CoreAnnotationNames.ValueConverterType];
-        if (type != null)
+        var annotation = property.FindAnnotation(CoreAnnotationNames.ValueConverterType);
+        if (annotation != null)
         {
-            return type;
+            return (Type?)annotation.Value;
         }
 
         var principalProperty = property;
-        for (var i = 0; i < 10000; i++)
+        var i = 0;
+        for (; i < ForeignKey.LongestFkChainAllowedLength; i++)
         {
+            IProperty? nextProperty = null;
             foreach (var foreignKey in principalProperty.GetContainingForeignKeys())
             {
                 for (var propertyIndex = 0; propertyIndex < foreignKey.Properties.Count; propertyIndex++)
                 {
                     if (principalProperty == foreignKey.Properties[propertyIndex])
                     {
                         var newPrincipalProperty = foreignKey.PrincipalKey.Properties[propertyIndex];
-                        if (property == principalProperty
+                        if (newPrincipalProperty == property
                             || newPrincipalProperty == principalProperty)
                         {
                             break;
                         }
 
-                        principalProperty = newPrincipalProperty;
-
-                        type = (Type?)principalProperty[CoreAnnotationNames.ValueConverterType];
-                        if (type != null)
+                        annotation = newPrincipalProperty.FindAnnotation(CoreAnnotationNames.ValueConverterType);
+                        if (annotation != null)
                         {
-                            return type;
+                            return (Type?)annotation.Value;
                         }
+
+                        nextProperty = newPrincipalProperty;
                     }
                 }
             }
+
+            if (nextProperty == null)
+            {
+                break;
+            }
+
+            principalProperty = nextProperty;
         }
 
-        return null;
+        return i == ForeignKey.LongestFkChainAllowedLength
+            ? throw new InvalidOperationException(CoreStrings.RelationshipCycle(
+                property.DeclaringEntityType.DisplayName(), property.Name, "ValueConverterType"))
+            : null;
     }
 
     private void PropertyBaseParameters(
diff --git a/src/EFCore/Infrastructure/ModelValidator.cs b/src/EFCore/Infrastructure/ModelValidator.cs
@@ -464,7 +464,7 @@ protected virtual void ValidateNoCycles(
         graph.TopologicalSort(
             tryBreakEdge: null,
             formatCycle: c => c.Select(d => d.Item1.DisplayName()).Join(" -> "),
-            c => CoreStrings.IdentifyingRelationshipCycle(c));
+            CoreStrings.IdentifyingRelationshipCycle);
     }
 
     /// <summary>
diff --git a/src/EFCore/Metadata/Internal/ForeignKey.cs b/src/EFCore/Metadata/Internal/ForeignKey.cs
@@ -34,6 +34,14 @@ public class ForeignKey : ConventionAnnotatable, IMutableForeignKey, IConvention
     private IDependentKeyValueFactory? _dependentKeyValueFactory;
     private Func<IDependentsMap>? _dependentsMapFactory;
 
+    /// <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 static readonly int LongestFkChainAllowedLength = 10000;
+
     /// <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
diff --git a/src/EFCore/Metadata/Internal/Property.cs b/src/EFCore/Metadata/Internal/Property.cs
@@ -613,7 +613,7 @@ public virtual PropertySaveBehavior GetAfterSaveBehavior()
         }
 
         RemoveAnnotation(CoreAnnotationNames.ValueConverterType);
-        return (ValueConverter?)SetOrRemoveAnnotation(CoreAnnotationNames.ValueConverter, converter, configurationSource)?.Value;
+        return (ValueConverter?)SetAnnotation(CoreAnnotationNames.ValueConverter, converter, configurationSource)?.Value;
     }
 
     /// <summary>
@@ -648,7 +648,7 @@ public virtual PropertySaveBehavior GetAfterSaveBehavior()
         }
 
         SetValueConverter(converter, configurationSource);
-        SetOrRemoveAnnotation(CoreAnnotationNames.ValueConverterType, converterType, configurationSource);
+        SetAnnotation(CoreAnnotationNames.ValueConverterType, converterType, configurationSource);
 
         return converterType;
     }
@@ -661,15 +661,17 @@ public virtual PropertySaveBehavior GetAfterSaveBehavior()
     /// </summary>
     public virtual ValueConverter? GetValueConverter()
     {
-        var converter = (ValueConverter?)this[CoreAnnotationNames.ValueConverter];
-        if (converter != null)
+        var annotation = FindAnnotation(CoreAnnotationNames.ValueConverter);
+        if (annotation != null)
         {
-            return converter;
+            return (ValueConverter?)annotation.Value;
         }
 
         var property = this;
-        for (var i = 0; i < 10000; i++)
+        var i = 0;
+        for (; i < ForeignKey.LongestFkChainAllowedLength; i++)
         {
+            Property? nextProperty = null;
             foreach (var foreignKey in property.GetContainingForeignKeys())
             {
                 for (var propertyIndex = 0; propertyIndex < foreignKey.Properties.Count; propertyIndex++)
@@ -683,19 +685,29 @@ public virtual PropertySaveBehavior GetAfterSaveBehavior()
                             break;
                         }
 
-                        property = principalProperty;
-
-                        converter = (ValueConverter?)property[CoreAnnotationNames.ValueConverter];
-                        if (converter != null)
+                        annotation = principalProperty.FindAnnotation(CoreAnnotationNames.ValueConverter);
+                        if (annotation != null)
                         {
-                            return converter;
+                            return (ValueConverter?)annotation.Value;
                         }
+
+                        nextProperty = principalProperty;
                     }
                 }
             }
+
+            if (nextProperty == null)
+            {
+                break;
+            }
+
+            property = nextProperty;
         }
 
-        return null;
+        return i == ForeignKey.LongestFkChainAllowedLength
+            ? throw new InvalidOperationException(CoreStrings.RelationshipCycle(
+                DeclaringEntityType.DisplayName(), Name, "ValueConverter"))
+            : null;
     }
 
     /// <summary>
@@ -730,7 +742,7 @@ public virtual PropertySaveBehavior GetAfterSaveBehavior()
     ///     doing so can result in application failures when updating to a new Entity Framework Core release.
     /// </summary>
     public virtual Type? SetProviderClrType(Type? providerClrType, ConfigurationSource configurationSource)
-        => (Type?)SetOrRemoveAnnotation(CoreAnnotationNames.ProviderClrType, providerClrType, configurationSource)?.Value;
+        => (Type?)SetAnnotation(CoreAnnotationNames.ProviderClrType, providerClrType, configurationSource)?.Value;
 
     /// <summary>
     ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
@@ -740,15 +752,17 @@ public virtual PropertySaveBehavior GetAfterSaveBehavior()
     /// </summary>
     public virtual Type? GetProviderClrType()
     {
-        var type = (Type?)this[CoreAnnotationNames.ProviderClrType];
-        if (type != null)
+        var annotation = FindAnnotation(CoreAnnotationNames.ProviderClrType);
+        if (annotation != null)
         {
-            return type;
+            return (Type?)annotation.Value;
         }
 
         var property = this;
-        for (var i = 0; i < 10000; i++)
+        var i = 0;
+        for (; i < ForeignKey.LongestFkChainAllowedLength; i++)
         {
+            Property? nextProperty = null;
             foreach (var foreignKey in property.GetContainingForeignKeys())
             {
                 for (var propertyIndex = 0; propertyIndex < foreignKey.Properties.Count; propertyIndex++)
@@ -762,19 +776,29 @@ public virtual PropertySaveBehavior GetAfterSaveBehavior()
                             break;
                         }
 
-                        property = principalProperty;
-
-                        type = (Type?)property[CoreAnnotationNames.ProviderClrType];
-                        if (type != null)
+                        annotation = principalProperty.FindAnnotation(CoreAnnotationNames.ProviderClrType);
+                        if (annotation != null)
                         {
-                            return type;
+                            return (Type?)annotation.Value;
                         }
+
+                        nextProperty = principalProperty;
                     }
                 }
             }
+
+            if (nextProperty == null)
+            {
+                break;
+            }
+
+            property = nextProperty;
         }
 
-        return null;
+        return i == ForeignKey.LongestFkChainAllowedLength
+            ? throw new InvalidOperationException(CoreStrings.RelationshipCycle(
+                DeclaringEntityType.DisplayName(), Name, "ProviderClrType"))
+            : null;
     }
 
     /// <summary>
diff --git a/src/EFCore/Properties/CoreStrings.Designer.cs b/src/EFCore/Properties/CoreStrings.Designer.cs
diff --git a/src/EFCore/Properties/CoreStrings.resx b/src/EFCore/Properties/CoreStrings.resx
@@ -1307,6 +1307,9 @@
   <data name="RelationshipConceptualNullSensitive" xml:space="preserve">
     <value>The association between entities '{firstType}' and '{secondType}' with the key value '{secondKeyValue}' has been severed, but the relationship is either marked as required or is implicitly required because the foreign key is not nullable. If the dependent/child entity should be deleted when a required relationship is severed, configure the relationship to use cascade deletes.</value>
   </data>
+  <data name="RelationshipCycle" xml:space="preserve">
+    <value>A relationship cycle involving the property '{entityType}.{property}' was detected. This prevents Entity Framework from determining the correct configuration. Review the foreign keys defined on the property and the corresponding principal property and either remove one of them or specify '{configuration}' explicitly on one of the properties.</value>
+  </data>
   <data name="RequiredSkipNavigation" xml:space="preserve">
     <value>'{entityType}.{navigation}' cannot be configured as required since it represents a skip navigation.</value>
   </data>
@@ -1505,4 +1508,4 @@
   <data name="WrongStateManager" xml:space="preserve">
     <value>Cannot start tracking the entry for entity type '{entityType}' because it was created by a different StateManager instance.</value>
   </data>
-</root>
+</root>
diff --git a/test/EFCore.SqlServer.FunctionalTests/SqlServerEndToEndTest.cs b/test/EFCore.SqlServer.FunctionalTests/SqlServerEndToEndTest.cs
@@ -1396,7 +1396,13 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
                     eb.HasKey(l => new { l.GameId, l.Id });
                 });
 
-            modelBuilder.Entity<Container>();
+            modelBuilder.Entity<Container>(
+                eb =>
+                {
+                    eb.HasMany(c => c.Items)
+                        .WithOne()
+                        .HasForeignKey("GameId", "ContainerId");
+                });
 
             modelBuilder.Entity<Game>(
                 eb =>
diff --git a/test/EFCore.Tests/Infrastructure/ModelValidatorTest.cs b/test/EFCore.Tests/Infrastructure/ModelValidatorTest.cs
@@ -472,16 +472,59 @@ public virtual void Detects_key_property_with_value_generated_on_add_or_update()
     }
 
     [ConditionalFact]
-    public virtual void Detects_relationship_cycle()
+    public virtual void Detects_identifying_relationship_cycle()
+    {
+        var modelBuilder = base.CreateConventionModelBuilder();
+
+        modelBuilder.Entity<C>().HasBaseType((string)null);
+        modelBuilder.Entity<A>().HasOne<B>().WithOne().HasForeignKey<A>(a => a.Id).HasPrincipalKey<B>(b => b.Id).IsRequired();
+        modelBuilder.Entity<A>().HasOne<C>().WithOne().HasForeignKey<C>(a => a.Id).HasPrincipalKey<A>(b => b.Id).IsRequired();
+        modelBuilder.Entity<C>().HasOne<B>().WithOne().HasForeignKey<B>(a => a.Id).HasPrincipalKey<C>(b => b.Id).IsRequired();
+
+        VerifyError(
+            CoreStrings.IdentifyingRelationshipCycle("A -> B -> C"),
+            modelBuilder);
+    }
+
+    [ConditionalFact]
+    public virtual void Detects_relationship_cycle_for_property_configuration()
     {
         var modelBuilder = base.CreateConventionModelBuilder();
 
-        modelBuilder.Entity<A>();
-        modelBuilder.Entity<B>();
         modelBuilder.Entity<C>().HasBaseType((string)null);
         modelBuilder.Entity<A>().HasOne<B>().WithOne().HasForeignKey<A>(a => a.Id).HasPrincipalKey<B>(b => b.Id).IsRequired();
         modelBuilder.Entity<A>().HasOne<C>().WithOne().HasForeignKey<C>(a => a.Id).HasPrincipalKey<A>(b => b.Id).IsRequired();
         modelBuilder.Entity<C>().HasOne<B>().WithOne().HasForeignKey<B>(a => a.Id).HasPrincipalKey<C>(b => b.Id).IsRequired();
+        modelBuilder.Entity<D>().HasBaseType((string)null);
+        modelBuilder.Entity<D>().HasOne<B>().WithOne().HasForeignKey<D>(a => a.Id).HasPrincipalKey<B>(b => b.Id).IsRequired();
+
+        var dId = modelBuilder.Model.FindEntityType(typeof(D)).FindProperty(nameof(D.Id));
+
+        Assert.Equal(CoreStrings.RelationshipCycle(nameof(D), nameof(D.Id), "ValueConverter"),
+            Assert.Throws<InvalidOperationException>(dId.GetValueConverter).Message);
+        Assert.Equal(CoreStrings.RelationshipCycle(nameof(D), nameof(D.Id), "ProviderClrType"),
+            Assert.Throws<InvalidOperationException>(dId.GetProviderClrType).Message);
+    }
+
+    [ConditionalFact]
+    public virtual void Detects_relationship_cycle_for_explicit_property_configuration()
+    {
+        var modelBuilder = base.CreateConventionModelBuilder();
+
+        modelBuilder.Entity<C>().HasBaseType((string)null);
+        modelBuilder.Entity<A>().HasOne<B>().WithOne().HasForeignKey<A>(a => a.Id).HasPrincipalKey<B>(b => b.Id).IsRequired();
+        modelBuilder.Entity<A>().HasOne<C>().WithOne().HasForeignKey<C>(a => a.Id).HasPrincipalKey<A>(b => b.Id).IsRequired();
+        modelBuilder.Entity<C>().HasOne<B>().WithOne().HasForeignKey<B>(a => a.Id).HasPrincipalKey<C>(b => b.Id).IsRequired();
+        modelBuilder.Entity<D>().HasBaseType((string)null);
+        modelBuilder.Entity<D>().HasOne<B>().WithOne().HasForeignKey<D>(a => a.Id).HasPrincipalKey<B>(b => b.Id).IsRequired();
+
+        var aId = modelBuilder.Model.FindEntityType(typeof(A)).FindProperty(nameof(A.Id));
+        aId.SetValueConverter((ValueConverter)null);
+        aId.SetProviderClrType(null);
+
+        var dId = modelBuilder.Model.FindEntityType(typeof(D)).FindProperty(nameof(D.Id));
+        Assert.Null(dId.GetValueConverter());
+        Assert.Null(dId.GetProviderClrType());
 
         VerifyError(
             CoreStrings.IdentifyingRelationshipCycle("A -> B -> C"),

Original file line number	Diff line number	Diff line change
`@@ -849,41 +849,53 @@ private void Create(`
`849`	`849`
`850`	`850`	`private static Type? GetValueConverterType(IProperty property)`
`851`	`851`	`{`
`852`		`- var type = (Type?)property[CoreAnnotationNames.ValueConverterType];`
`853`		`- if (type != null)`
	`852`	`+ var annotation = property.FindAnnotation(CoreAnnotationNames.ValueConverterType);`
	`853`	`+ if (annotation != null)`
`854`	`854`	`{`
`855`		`- return type;`
	`855`	`+ return (Type?)annotation.Value;`
`856`	`856`	`}`
`857`	`857`
`858`	`858`	`var principalProperty = property;`
`859`		`- for (var i = 0; i < 10000; i++)`
	`859`	`+ var i = 0;`
	`860`	`+ for (; i < ForeignKey.LongestFkChainAllowedLength; i++)`
`860`	`861`	`{`
	`862`	`+ IProperty? nextProperty = null;`
`861`	`863`	`foreach (var foreignKey in principalProperty.GetContainingForeignKeys())`
`862`	`864`	`{`
`863`	`865`	`for (var propertyIndex = 0; propertyIndex < foreignKey.Properties.Count; propertyIndex++)`
`864`	`866`	`{`
`865`	`867`	`if (principalProperty == foreignKey.Properties[propertyIndex])`
`866`	`868`	`{`
`867`	`869`	`var newPrincipalProperty = foreignKey.PrincipalKey.Properties[propertyIndex];`
`868`		`- if (property == principalProperty`
	`870`	`+ if (newPrincipalProperty == property`
`869`	`871`	`\|\| newPrincipalProperty == principalProperty)`
`870`	`872`	`{`
`871`	`873`	`break;`
`872`	`874`	`}`
`873`	`875`
`874`		`- principalProperty = newPrincipalProperty;`
`875`		`-`
`876`		`- type = (Type?)principalProperty[CoreAnnotationNames.ValueConverterType];`
`877`		`- if (type != null)`
	`876`	`+ annotation = newPrincipalProperty.FindAnnotation(CoreAnnotationNames.ValueConverterType);`
	`877`	`+ if (annotation != null)`
`878`	`878`	`{`
`879`		`- return type;`
	`879`	`+ return (Type?)annotation.Value;`
`880`	`880`	`}`
	`881`	`+`
	`882`	`+ nextProperty = newPrincipalProperty;`
`881`	`883`	`}`
`882`	`884`	`}`
`883`	`885`	`}`
	`886`	`+`
	`887`	`+ if (nextProperty == null)`
	`888`	`+ {`
	`889`	`+ break;`
	`890`	`+ }`
	`891`	`+`
	`892`	`+ principalProperty = nextProperty;`
`884`	`893`	`}`
`885`	`894`
`886`		`- return null;`
	`895`	`+ return i == ForeignKey.LongestFkChainAllowedLength`
	`896`	`+ ? throw new InvalidOperationException(CoreStrings.RelationshipCycle(`
	`897`	`+ property.DeclaringEntityType.DisplayName(), property.Name, "ValueConverterType"))`
	`898`	`+ : null;`
`887`	`899`	`}`
`888`	`900`
`889`	`901`	`private void PropertyBaseParameters(`
Original file line number	Diff line number	Diff line change
`@@ -464,7 +464,7 @@ protected virtual void ValidateNoCycles(`
`464`	`464`	`graph.TopologicalSort(`
`465`	`465`	`tryBreakEdge: null,`
`466`	`466`	`formatCycle: c => c.Select(d => d.Item1.DisplayName()).Join(" -> "),`
`467`		`- c => CoreStrings.IdentifyingRelationshipCycle(c));`
	`467`	`+ CoreStrings.IdentifyingRelationshipCycle);`
`468`	`468`	`}`
`469`	`469`
`470`	`470`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -613,7 +613,7 @@ public virtual PropertySaveBehavior GetAfterSaveBehavior()`
`613`	`613`	`}`
`614`	`614`
`615`	`615`	`RemoveAnnotation(CoreAnnotationNames.ValueConverterType);`
`616`		`- return (ValueConverter?)SetOrRemoveAnnotation(CoreAnnotationNames.ValueConverter, converter, configurationSource)?.Value;`
	`616`	`+ return (ValueConverter?)SetAnnotation(CoreAnnotationNames.ValueConverter, converter, configurationSource)?.Value;`
`617`	`617`	`}`
`618`	`618`
`619`	`619`	`/// <summary>`
`@@ -648,7 +648,7 @@ public virtual PropertySaveBehavior GetAfterSaveBehavior()`
`648`	`648`	`}`
`649`	`649`
`650`	`650`	`SetValueConverter(converter, configurationSource);`
`651`		`- SetOrRemoveAnnotation(CoreAnnotationNames.ValueConverterType, converterType, configurationSource);`
	`651`	`+ SetAnnotation(CoreAnnotationNames.ValueConverterType, converterType, configurationSource);`
`652`	`652`
`653`	`653`	`return converterType;`
`654`	`654`	`}`
`@@ -661,15 +661,17 @@ public virtual PropertySaveBehavior GetAfterSaveBehavior()`
`661`	`661`	`/// </summary>`
`662`	`662`	`public virtual ValueConverter? GetValueConverter()`
`663`	`663`	`{`
`664`		`- var converter = (ValueConverter?)this[CoreAnnotationNames.ValueConverter];`
`665`		`- if (converter != null)`
	`664`	`+ var annotation = FindAnnotation(CoreAnnotationNames.ValueConverter);`
	`665`	`+ if (annotation != null)`
`666`	`666`	`{`
`667`		`- return converter;`
	`667`	`+ return (ValueConverter?)annotation.Value;`
`668`	`668`	`}`
`669`	`669`
`670`	`670`	`var property = this;`
`671`		`- for (var i = 0; i < 10000; i++)`
	`671`	`+ var i = 0;`
	`672`	`+ for (; i < ForeignKey.LongestFkChainAllowedLength; i++)`
`672`	`673`	`{`
	`674`	`+ Property? nextProperty = null;`
`673`	`675`	`foreach (var foreignKey in property.GetContainingForeignKeys())`
`674`	`676`	`{`
`675`	`677`	`for (var propertyIndex = 0; propertyIndex < foreignKey.Properties.Count; propertyIndex++)`
`@@ -683,19 +685,29 @@ public virtual PropertySaveBehavior GetAfterSaveBehavior()`
`683`	`685`	`break;`
`684`	`686`	`}`
`685`	`687`
`686`		`- property = principalProperty;`
`687`		`-`
`688`		`- converter = (ValueConverter?)property[CoreAnnotationNames.ValueConverter];`
`689`		`- if (converter != null)`
	`688`	`+ annotation = principalProperty.FindAnnotation(CoreAnnotationNames.ValueConverter);`
	`689`	`+ if (annotation != null)`
`690`	`690`	`{`
`691`		`- return converter;`
	`691`	`+ return (ValueConverter?)annotation.Value;`
`692`	`692`	`}`
	`693`	`+`
	`694`	`+ nextProperty = principalProperty;`
`693`	`695`	`}`
`694`	`696`	`}`
`695`	`697`	`}`
	`698`	`+`
	`699`	`+ if (nextProperty == null)`
	`700`	`+ {`
	`701`	`+ break;`
	`702`	`+ }`
	`703`	`+`
	`704`	`+ property = nextProperty;`
`696`	`705`	`}`
`697`	`706`
`698`		`- return null;`
	`707`	`+ return i == ForeignKey.LongestFkChainAllowedLength`
	`708`	`+ ? throw new InvalidOperationException(CoreStrings.RelationshipCycle(`
	`709`	`+ DeclaringEntityType.DisplayName(), Name, "ValueConverter"))`
	`710`	`+ : null;`
`699`	`711`	`}`
`700`	`712`
`701`	`713`	`/// <summary>`
`@@ -730,7 +742,7 @@ public virtual PropertySaveBehavior GetAfterSaveBehavior()`
`730`	`742`	`/// doing so can result in application failures when updating to a new Entity Framework Core release.`
`731`	`743`	`/// </summary>`
`732`	`744`	`public virtual Type? SetProviderClrType(Type? providerClrType, ConfigurationSource configurationSource)`
`733`		`- => (Type?)SetOrRemoveAnnotation(CoreAnnotationNames.ProviderClrType, providerClrType, configurationSource)?.Value;`
	`745`	`+ => (Type?)SetAnnotation(CoreAnnotationNames.ProviderClrType, providerClrType, configurationSource)?.Value;`
`734`	`746`
`735`	`747`	`/// <summary>`
`736`	`748`	`/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to`
`@@ -740,15 +752,17 @@ public virtual PropertySaveBehavior GetAfterSaveBehavior()`
`740`	`752`	`/// </summary>`
`741`	`753`	`public virtual Type? GetProviderClrType()`
`742`	`754`	`{`
`743`		`- var type = (Type?)this[CoreAnnotationNames.ProviderClrType];`
`744`		`- if (type != null)`
	`755`	`+ var annotation = FindAnnotation(CoreAnnotationNames.ProviderClrType);`
	`756`	`+ if (annotation != null)`
`745`	`757`	`{`
`746`		`- return type;`
	`758`	`+ return (Type?)annotation.Value;`
`747`	`759`	`}`
`748`	`760`
`749`	`761`	`var property = this;`
`750`		`- for (var i = 0; i < 10000; i++)`
	`762`	`+ var i = 0;`
	`763`	`+ for (; i < ForeignKey.LongestFkChainAllowedLength; i++)`
`751`	`764`	`{`
	`765`	`+ Property? nextProperty = null;`
`752`	`766`	`foreach (var foreignKey in property.GetContainingForeignKeys())`
`753`	`767`	`{`
`754`	`768`	`for (var propertyIndex = 0; propertyIndex < foreignKey.Properties.Count; propertyIndex++)`
`@@ -762,19 +776,29 @@ public virtual PropertySaveBehavior GetAfterSaveBehavior()`
`762`	`776`	`break;`
`763`	`777`	`}`
`764`	`778`
`765`		`- property = principalProperty;`
`766`		`-`
`767`		`- type = (Type?)property[CoreAnnotationNames.ProviderClrType];`
`768`		`- if (type != null)`
	`779`	`+ annotation = principalProperty.FindAnnotation(CoreAnnotationNames.ProviderClrType);`
	`780`	`+ if (annotation != null)`
`769`	`781`	`{`
`770`		`- return type;`
	`782`	`+ return (Type?)annotation.Value;`
`771`	`783`	`}`
	`784`	`+`
	`785`	`+ nextProperty = principalProperty;`
`772`	`786`	`}`
`773`	`787`	`}`
`774`	`788`	`}`
	`789`	`+`
	`790`	`+ if (nextProperty == null)`
	`791`	`+ {`
	`792`	`+ break;`
	`793`	`+ }`
	`794`	`+`
	`795`	`+ property = nextProperty;`
`775`	`796`	`}`
`776`	`797`
`777`		`- return null;`
	`798`	`+ return i == ForeignKey.LongestFkChainAllowedLength`
	`799`	`+ ? throw new InvalidOperationException(CoreStrings.RelationshipCycle(`
	`800`	`+ DeclaringEntityType.DisplayName(), Name, "ProviderClrType"))`
	`801`	`+ : null;`
`778`	`802`	`}`
`779`	`803`
`780`	`804`	`/// <summary>`