Ensure entities from query are tracked as correct type

ajcvickers · ajcvickers · commit 8c1d2581f233 · 2016-03-30T13:43:23.000-07:00
Issue #4817 The problem was that query was passing in the base type to the state manager since the actual type varies by row. It would likely be possible to flow the actual type through from the materializer but this would require significant changes and would not be used in a lot of cases. Instead the state manager now looks up the entity type if it is not the base type, with some optimizations to that lookup made in metadata.
diff --git a/src/Microsoft.EntityFrameworkCore/ChangeTracking/Internal/IStateManager.cs b/src/Microsoft.EntityFrameworkCore/ChangeTracking/Internal/IStateManager.cs
@@ -15,7 +15,7 @@ public interface IStateManager
     {
         InternalEntityEntry GetOrCreateEntry([NotNull] object entity);
 
-        InternalEntityEntry StartTrackingFromQuery([NotNull] IEntityType entityType, [NotNull] object entity, ValueBuffer valueBuffer);
+        InternalEntityEntry StartTrackingFromQuery([NotNull] IEntityType baseEntityType, [NotNull] object entity, ValueBuffer valueBuffer);
 
         void BeginTrackingQuery();
 
diff --git a/src/Microsoft.EntityFrameworkCore/ChangeTracking/Internal/StateManager.cs b/src/Microsoft.EntityFrameworkCore/ChangeTracking/Internal/StateManager.cs
@@ -84,7 +84,7 @@ public virtual InternalEntityEntry GetOrCreateEntry(object entity)
         public virtual void BeginTrackingQuery() => SingleQueryMode = SingleQueryMode == null;
 
         public virtual InternalEntityEntry StartTrackingFromQuery(
-            IEntityType entityType,
+            IEntityType baseEntityType,
             object entity,
             ValueBuffer valueBuffer)
         {
@@ -94,11 +94,17 @@ public virtual InternalEntityEntry StartTrackingFromQuery(
                 return existingEntry;
             }
 
-            var newEntry = _factory.Create(this, entityType, entity, valueBuffer);
+            var clrType = entity.GetType();
+
+            var newEntry = _factory.Create(this,
+                baseEntityType.ClrType == clrType
+                    ? baseEntityType
+                    : _model.FindEntityType(clrType),
+                entity, valueBuffer);
 
             _subscriber.SnapshotAndSubscribe(newEntry);
 
-            foreach (var key in entityType.GetKeys())
+            foreach (var key in baseEntityType.GetKeys())
             {
                 GetOrCreateIdentityMap(key).AddOrUpdate(newEntry);
             }
diff --git a/src/Microsoft.EntityFrameworkCore/Extensions/EntityTypeExtensions.cs b/src/Microsoft.EntityFrameworkCore/Extensions/EntityTypeExtensions.cs
@@ -28,8 +28,8 @@ public static IEnumerable<IEntityType> GetDerivedTypes([NotNull] this IEntityTyp
             // ReSharper disable once LoopCanBeConvertedToQuery
             foreach (var derivedType in entityType.Model.GetEntityTypes())
             {
-                if ((derivedType.BaseType != null)
-                    && (derivedType != entityType)
+                if (derivedType.BaseType != null
+                    && derivedType != entityType
                     && entityType.IsAssignableFrom(derivedType))
                 {
                     yield return derivedType;
diff --git a/src/Microsoft.EntityFrameworkCore/Extensions/ModelExtensions.cs b/src/Microsoft.EntityFrameworkCore/Extensions/ModelExtensions.cs
@@ -5,6 +5,7 @@
 using JetBrains.Annotations;
 using Microsoft.EntityFrameworkCore.Internal;
 using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Metadata.Internal;
 using Microsoft.EntityFrameworkCore.Utilities;
 
 namespace Microsoft.EntityFrameworkCore
@@ -24,7 +25,11 @@ public static IEntityType FindEntityType([NotNull] this IModel model, [NotNull]
         {
             Check.NotNull(type, nameof(type));
 
-            return model.FindEntityType(type.DisplayName());
+            var canFindEntityType = model as ICanFindEntityType;
+
+            return canFindEntityType != null
+                ? canFindEntityType.FindEntityType(type)
+                : model.FindEntityType(type.DisplayName());
         }
     }
 }
diff --git a/src/Microsoft.EntityFrameworkCore/Extensions/MutableModelExtensions.cs b/src/Microsoft.EntityFrameworkCore/Extensions/MutableModelExtensions.cs
@@ -5,6 +5,7 @@
 using JetBrains.Annotations;
 using Microsoft.EntityFrameworkCore.Internal;
 using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Metadata.Internal;
 using Microsoft.EntityFrameworkCore.Utilities;
 
 namespace Microsoft.EntityFrameworkCore
@@ -44,8 +45,14 @@ public static IMutableEntityType AddEntityType([NotNull] this IMutableModel mode
             Check.NotNull(model, nameof(model));
             Check.NotNull(type, nameof(type));
 
-            var entityType = model.AddEntityType(type.DisplayName());
+            var canFindEntityType = model as ICanFindEntityType;
+
+            var entityType = canFindEntityType != null
+                ? canFindEntityType.AddEntityType(type.DisplayName(), type) :
+                model.AddEntityType(type.DisplayName());
+
             entityType.ClrType = type;
+
             return entityType;
         }
 
diff --git a/src/Microsoft.EntityFrameworkCore/Metadata/Internal/ICanFindEntityType.cs b/src/Microsoft.EntityFrameworkCore/Metadata/Internal/ICanFindEntityType.cs
@@ -0,0 +1,14 @@
+// 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 JetBrains.Annotations;
+
+namespace Microsoft.EntityFrameworkCore.Metadata.Internal
+{
+    public interface ICanFindEntityType
+    {
+        IEntityType FindEntityType([NotNull] Type type);
+        IMutableEntityType AddEntityType([NotNull] string name, [CanBeNull] Type type);
+    }
+}
diff --git a/src/Microsoft.EntityFrameworkCore/Metadata/Internal/InternalModelBuilder.cs b/src/Microsoft.EntityFrameworkCore/Metadata/Internal/InternalModelBuilder.cs
@@ -31,7 +31,7 @@ public virtual InternalEntityTypeBuilder Entity([NotNull] string name, Configura
             {
                 Metadata.Unignore(name);
 
-                entityType = Metadata.AddEntityType(name, configurationSource);
+                entityType = Metadata.AddEntityType(name, null, configurationSource);
             }
             else
             {
diff --git a/src/Microsoft.EntityFrameworkCore/Metadata/Internal/Model.cs b/src/Microsoft.EntityFrameworkCore/Metadata/Internal/Model.cs
@@ -13,9 +13,13 @@
 
 namespace Microsoft.EntityFrameworkCore.Metadata.Internal
 {
-    public class Model : ConventionalAnnotatable, IMutableModel
+    public class Model : ConventionalAnnotatable, IMutableModel, ICanFindEntityType
     {
-        private readonly SortedDictionary<string, EntityType> _entityTypes = new SortedDictionary<string, EntityType>();
+        private readonly SortedDictionary<string, EntityType> _entityTypes
+            = new SortedDictionary<string, EntityType>();
+
+        private readonly IDictionary<Type, EntityType> _clrTypeMap
+            = new Dictionary<Type, EntityType>();
 
         private readonly Dictionary<string, ConfigurationSource> _ignoredEntityTypeNames
             = new Dictionary<string, ConfigurationSource>();
@@ -38,47 +42,53 @@ public Model([NotNull] ConventionSet conventions)
         public virtual IEnumerable<EntityType> GetEntityTypes() => _entityTypes.Values;
 
         public virtual EntityType AddEntityType(
-            [NotNull] string name, ConfigurationSource configurationSource = ConfigurationSource.Explicit)
+            [NotNull] string name, [CanBeNull] Type type = null, ConfigurationSource configurationSource = ConfigurationSource.Explicit)
         {
             Check.NotEmpty(name, nameof(name));
 
-            var entityType = AddEntityTypeWithoutConventions(name, configurationSource);
-
-            return ConventionDispatcher.OnEntityTypeAdded(entityType.Builder)?.Metadata;
-        }
-
-        public virtual EntityType AddEntityType(
-            [NotNull] Type type, ConfigurationSource configurationSource = ConfigurationSource.Explicit)
-        {
-            Check.NotNull(type, nameof(type));
-
-            var entityType = AddEntityTypeWithoutConventions(type.DisplayName(), configurationSource);
-            entityType.ClrType = type;
-
-            return ConventionDispatcher.OnEntityTypeAdded(entityType.Builder)?.Metadata;
-        }
-
-        private EntityType AddEntityTypeWithoutConventions(string name, ConfigurationSource configurationSource)
-        {
             var entityType = new EntityType(name, this, configurationSource);
+
             var previousLength = _entityTypes.Count;
             _entityTypes[name] = entityType;
-
             if (previousLength == _entityTypes.Count)
             {
                 throw new InvalidOperationException(CoreStrings.DuplicateEntityType(entityType.Name));
             }
-            return entityType;
+
+            if (type != null)
+            {
+                entityType.ClrType = type;
+                _clrTypeMap[type] = entityType;
+            }
+
+            return ConventionDispatcher.OnEntityTypeAdded(entityType.Builder)?.Metadata;
         }
 
+        IMutableEntityType ICanFindEntityType.AddEntityType(string name, Type type) 
+            => AddEntityType(name, type);
+
+        public virtual EntityType AddEntityType(
+            [NotNull] Type type, ConfigurationSource configurationSource = ConfigurationSource.Explicit) 
+            => AddEntityType(type.DisplayName(), type, configurationSource);
+
         public virtual EntityType GetOrAddEntityType([NotNull] Type type)
             => FindEntityType(type) ?? AddEntityType(type);
 
         public virtual EntityType GetOrAddEntityType([NotNull] string name)
             => FindEntityType(name) ?? AddEntityType(name);
 
-        public virtual EntityType FindEntityType([NotNull] Type type)
-            => (EntityType)((IMutableModel)this).FindEntityType(type);
+        public virtual EntityType FindEntityType([NotNull] Type type) 
+            => (EntityType)((ICanFindEntityType)this).FindEntityType(type);
+
+        IEntityType ICanFindEntityType.FindEntityType(Type type)
+        {
+            Check.NotNull(type, nameof(type));
+
+            EntityType entityType;
+            return _clrTypeMap.TryGetValue(type, out entityType)
+                ? entityType
+                : FindEntityType(type.DisplayName());
+        }
 
         public virtual EntityType FindEntityType([NotNull] string name)
         {
@@ -129,6 +139,11 @@ private EntityType RemoveEntityType([NotNull] EntityType entityType)
                         derivedEntityType.DisplayName()));
             }
 
+            if (entityType.ClrType != null)
+            {
+                _clrTypeMap.Remove(entityType.ClrType);
+            }
+
             var removed = _entityTypes.Remove(entityType.Name);
             Debug.Assert(removed);
             entityType.Builder = null;
diff --git a/src/Microsoft.EntityFrameworkCore/Microsoft.EntityFrameworkCore.csproj b/src/Microsoft.EntityFrameworkCore/Microsoft.EntityFrameworkCore.csproj
@@ -320,6 +320,7 @@
     <Compile Include="Metadata\Internal\IEntityMaterializer.cs" />
     <Compile Include="Metadata\Internal\IEntityMaterializerSource.cs" />
     <Compile Include="Metadata\Internal\IFieldMatcher.cs" />
+    <Compile Include="Metadata\Internal\ICanFindEntityType.cs" />
     <Compile Include="Metadata\Internal\IIdentityMapFactorySource.cs" />
     <Compile Include="Metadata\Internal\IMemberMapper.cs" />
     <Compile Include="Metadata\Internal\INavigationAccessors.cs" />
diff --git a/test/Microsoft.EntityFrameworkCore.FunctionalTests/InheritanceRelationshipsQueryTestBase.cs b/test/Microsoft.EntityFrameworkCore.FunctionalTests/InheritanceRelationshipsQueryTestBase.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.Collections.Generic;
 using System.Linq;
 using Microsoft.EntityFrameworkCore.FunctionalTests.TestModels.InheritanceRelationships;
 using Microsoft.EntityFrameworkCore.Metadata.Internal;
@@ -13,6 +14,38 @@ public abstract class InheritanceRelationshipsQueryTestBase<TTestStore, TFixture
     where TTestStore : TestStore
     where TFixture : InheritanceRelationshipsQueryFixtureBase<TTestStore>, new()
     {
+        [Fact]
+        public virtual void Changes_in_derived_related_entities_are_detected()
+        {
+            using (var context = CreateContext())
+            {
+                context.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.TrackAll;
+
+                var derivedEntity = context.BaseEntities.Include(e => e.BaseCollectionOnBase)
+                    .Single(e => e.Name == "Derived1(4)") as DerivedInheritanceRelationshipEntity;
+
+                var firstRelatedEntity = derivedEntity.BaseCollectionOnBase.Cast<DerivedCollectionOnBase>().First();
+
+                var originalValue = firstRelatedEntity.DerivedProperty;
+                Assert.NotEqual(0, originalValue);
+
+                var entry = context.ChangeTracker.Entries<DerivedCollectionOnBase>()
+                    .Single(e => e.Entity == firstRelatedEntity);
+
+                Assert.IsType<DerivedCollectionOnBase>(entry.Entity);
+
+                Assert.Equal(
+                    "Microsoft.EntityFrameworkCore.FunctionalTests.TestModels.InheritanceRelationships.DerivedCollectionOnBase", 
+                    entry.Metadata.Name);
+
+                firstRelatedEntity.DerivedProperty = originalValue + 1;
+                context.ChangeTracker.DetectChanges();
+
+                Assert.Equal(EntityState.Modified, entry.State);
+                Assert.Equal(originalValue, entry.Property(e => e.DerivedProperty).OriginalValue);
+                Assert.Equal(originalValue + 1, entry.Property(e => e.DerivedProperty).CurrentValue);
+            }
+        }
 
         [Fact]
         public virtual void Entity_can_make_separate_relationships_with_base_type_and_derived_type_both()
@@ -194,6 +227,7 @@ public virtual void Include_collection_with_inheritance1()
                 var result = query.ToList();
 
                 Assert.Equal(6, result.Count);
+                Assert.Equal(3, result.SelectMany(e => e.BaseCollectionOnBase.OfType<DerivedCollectionOnBase>()).Count(e => e.DerivedProperty != 0));
             }
         }
 
@@ -231,6 +265,7 @@ public virtual void Include_collection_with_inheritance_with_filter1()
                 var result = query.ToList();
 
                 Assert.Equal(6, result.Count);
+                Assert.Equal(3, result.SelectMany(e => e.BaseCollectionOnBase.OfType<DerivedCollectionOnBase>()).Count(e => e.DerivedProperty != 0));
             }
         }
 
@@ -474,6 +509,7 @@ public virtual void Include_collection_with_inheritance_on_derived1()
                 var result = query.ToList();
 
                 Assert.Equal(3, result.Count);
+                Assert.Equal(2, result.SelectMany(e => e.BaseCollectionOnBase.OfType<DerivedCollectionOnBase>()).Count(e => e.DerivedProperty != 0));
             }
         }
 
@@ -660,6 +696,7 @@ public virtual void Nested_include_with_inheritance_collection_reference1()
                 var result = query.ToList();
 
                 Assert.Equal(6, result.Count);
+                Assert.Equal(3, result.SelectMany(e => e.BaseCollectionOnBase.OfType<DerivedCollectionOnBase>()).Count(e => e.DerivedProperty != 0));
             }
         }
 
@@ -723,6 +760,7 @@ public virtual void Nested_include_with_inheritance_collection_collection1()
                 var result = query.ToList();
 
                 Assert.Equal(6, result.Count);
+                Assert.Equal(3, result.SelectMany(e => e.BaseCollectionOnBase.OfType<DerivedCollectionOnBase>()).Count(e => e.DerivedProperty != 0));
             }
         }
 
diff --git a/test/Microsoft.EntityFrameworkCore.FunctionalTests/TestModels/InheritanceRelationships/DerivedCollectionOnBase.cs b/test/Microsoft.EntityFrameworkCore.FunctionalTests/TestModels/InheritanceRelationships/DerivedCollectionOnBase.cs
@@ -5,5 +5,6 @@ namespace Microsoft.EntityFrameworkCore.FunctionalTests.TestModels.InheritanceRe
 {
     public class DerivedCollectionOnBase : BaseCollectionOnBase
     {
+        public int DerivedProperty { get; set; }
     }
 }
diff --git a/test/Microsoft.EntityFrameworkCore.FunctionalTests/TestModels/InheritanceRelationships/InheritanceRelationshipsModelInitializer.cs b/test/Microsoft.EntityFrameworkCore.FunctionalTests/TestModels/InheritanceRelationships/InheritanceRelationshipsModelInitializer.cs
@@ -72,14 +72,14 @@ public static void Seed(InheritanceRelationshipsContext context)
 
             context.BaseCollectionsOnBase.AddRange(bcob11, bcob12, bcob21, bcob31, bcob32);
 
-            var dcob11 = new DerivedCollectionOnBase { Name = "DCOB11", NestedReference = nrd2, NestedCollection = new List<NestedCollectionBase> { ncd21 } };
-            var dcob12 = new DerivedCollectionOnBase { Name = "DCOB12", NestedReference = nrb3, NestedCollection = new List<NestedCollectionBase> { ncb31 } };
-            var dcob21 = new DerivedCollectionOnBase { Name = "DCOB21" };
-            var dcob31 = new DerivedCollectionOnBase { Name = "DCOB31", NestedReference = nrd3, NestedCollection = new List<NestedCollectionBase> { ncd31, ncd32 } };
-            var dcob32 = new DerivedCollectionOnBase { Name = "DCOB32" };
-            var dcob41 = new DerivedCollectionOnBase { Name = "DCOB41" };
-            var dcob51 = new DerivedCollectionOnBase { Name = "DCOB51 (dangling)", NestedReference = nrd4, NestedCollection = new List<NestedCollectionBase> { ncd41, ncd42 } };
-            var dcob52 = new DerivedCollectionOnBase { Name = "DCOB52 (dangling)" };
+            var dcob11 = new DerivedCollectionOnBase { Name = "DCOB11", NestedReference = nrd2, NestedCollection = new List<NestedCollectionBase> { ncd21 }, DerivedProperty = 1 };
+            var dcob12 = new DerivedCollectionOnBase { Name = "DCOB12", NestedReference = nrb3, NestedCollection = new List<NestedCollectionBase> { ncb31 }, DerivedProperty = 2 };
+            var dcob21 = new DerivedCollectionOnBase { Name = "DCOB21", DerivedProperty = 3 };
+            var dcob31 = new DerivedCollectionOnBase { Name = "DCOB31", NestedReference = nrd3, NestedCollection = new List<NestedCollectionBase> { ncd31, ncd32 }, DerivedProperty = 4 };
+            var dcob32 = new DerivedCollectionOnBase { Name = "DCOB32", DerivedProperty = 5 };
+            var dcob41 = new DerivedCollectionOnBase { Name = "DCOB41", DerivedProperty = 6 };
+            var dcob51 = new DerivedCollectionOnBase { Name = "DCOB51 (dangling)", NestedReference = nrd4, NestedCollection = new List<NestedCollectionBase> { ncd41, ncd42 }, DerivedProperty = 7 };
+            var dcob52 = new DerivedCollectionOnBase { Name = "DCOB52 (dangling)", DerivedProperty = 8 };
 
             context.BaseCollectionsOnBase.AddRange(dcob11, dcob12, dcob21, dcob31, dcob32, dcob41, dcob51, dcob52);
 
diff --git a/test/Microsoft.EntityFrameworkCore.SqlServer.FunctionalTests/InheritanceRelationshipsQuerySqlServerTest.cs b/test/Microsoft.EntityFrameworkCore.SqlServer.FunctionalTests/InheritanceRelationshipsQuerySqlServerTest.cs
diff --git a/test/Microsoft.EntityFrameworkCore.Tests/DbContextTest.cs b/test/Microsoft.EntityFrameworkCore.Tests/DbContextTest.cs

Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ public interface IStateManager`
`15`	`15`	`{`
`16`	`16`	`InternalEntityEntry GetOrCreateEntry([NotNull] object entity);`
`17`	`17`
`18`		`- InternalEntityEntry StartTrackingFromQuery([NotNull] IEntityType entityType, [NotNull] object entity, ValueBuffer valueBuffer);`
	`18`	`+ InternalEntityEntry StartTrackingFromQuery([NotNull] IEntityType baseEntityType, [NotNull] object entity, ValueBuffer valueBuffer);`
`19`	`19`
`20`	`20`	`void BeginTrackingQuery();`
`21`	`21`
Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,7 @@ public virtual InternalEntityEntry GetOrCreateEntry(object entity)`
`84`	`84`	`public virtual void BeginTrackingQuery() => SingleQueryMode = SingleQueryMode == null;`
`85`	`85`
`86`	`86`	`public virtual InternalEntityEntry StartTrackingFromQuery(`
`87`		`- IEntityType entityType,`
	`87`	`+ IEntityType baseEntityType,`
`88`	`88`	`object entity,`
`89`	`89`	`ValueBuffer valueBuffer)`
`90`	`90`	`{`
`@@ -94,11 +94,17 @@ public virtual InternalEntityEntry StartTrackingFromQuery(`
`94`	`94`	`return existingEntry;`
`95`	`95`	`}`
`96`	`96`
`97`		`- var newEntry = _factory.Create(this, entityType, entity, valueBuffer);`
	`97`	`+ var clrType = entity.GetType();`
	`98`	`+`
	`99`	`+ var newEntry = _factory.Create(this,`
	`100`	`+ baseEntityType.ClrType == clrType`
	`101`	`+ ? baseEntityType`
	`102`	`+ : _model.FindEntityType(clrType),`
	`103`	`+ entity, valueBuffer);`
`98`	`104`
`99`	`105`	`_subscriber.SnapshotAndSubscribe(newEntry);`
`100`	`106`
`101`		`- foreach (var key in entityType.GetKeys())`
	`107`	`+ foreach (var key in baseEntityType.GetKeys())`
`102`	`108`	`{`
`103`	`109`	`GetOrCreateIdentityMap(key).AddOrUpdate(newEntry);`
`104`	`110`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,8 +28,8 @@ public static IEnumerable<IEntityType> GetDerivedTypes([NotNull] this IEntityTyp`
`28`	`28`	`// ReSharper disable once LoopCanBeConvertedToQuery`
`29`	`29`	`foreach (var derivedType in entityType.Model.GetEntityTypes())`
`30`	`30`	`{`
`31`		`- if ((derivedType.BaseType != null)`
`32`		`- && (derivedType != entityType)`
	`31`	`+ if (derivedType.BaseType != null`
	`32`	`+ && derivedType != entityType`
`33`	`33`	`&& entityType.IsAssignableFrom(derivedType))`
`34`	`34`	`{`
`35`	`35`	`yield return derivedType;`
Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,7 @@`
`5`	`5`	`using JetBrains.Annotations;`
`6`	`6`	`using Microsoft.EntityFrameworkCore.Internal;`
`7`	`7`	`using Microsoft.EntityFrameworkCore.Metadata;`
	`8`	`+using Microsoft.EntityFrameworkCore.Metadata.Internal;`
`8`	`9`	`using Microsoft.EntityFrameworkCore.Utilities;`
`9`	`10`
`10`	`11`	`namespace Microsoft.EntityFrameworkCore`
`@@ -24,7 +25,11 @@ public static IEntityType FindEntityType([NotNull] this IModel model, [NotNull]`
`24`	`25`	`{`
`25`	`26`	`Check.NotNull(type, nameof(type));`
`26`	`27`
`27`		`- return model.FindEntityType(type.DisplayName());`
	`28`	`+ var canFindEntityType = model as ICanFindEntityType;`
	`29`	`+`
	`30`	`+ return canFindEntityType != null`
	`31`	`+ ? canFindEntityType.FindEntityType(type)`
	`32`	`+ : model.FindEntityType(type.DisplayName());`
`28`	`33`	`}`
`29`	`34`	`}`
`30`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ public virtual InternalEntityTypeBuilder Entity([NotNull] string name, Configura`
`31`	`31`	`{`
`32`	`32`	`Metadata.Unignore(name);`
`33`	`33`
`34`		`- entityType = Metadata.AddEntityType(name, configurationSource);`
	`34`	`+ entityType = Metadata.AddEntityType(name, null, configurationSource);`
`35`	`35`	`}`
`36`	`36`	`else`
`37`	`37`	`{`