Be more resilient when using the model from the model snapshot

Fixes #17145 but see also #17205

The fix here allows the state manager to work, which is required when the model snapshot has model data in it.

src/EFCore.InMemory/Storage/Internal/InMemoryTable.cs

@@ -89,7 +89,7 @@ private static List<ValueComparer> GetStructuralComparers(IEnumerable<IProperty>
             => properties.Select(GetStructuralComparer).ToList();
 
         private static ValueComparer GetStructuralComparer(IProperty p)
-            => p.GetStructuralValueComparer() ?? p.GetTypeMapping().StructuralComparer;
+            => p.GetStructuralValueComparer() ?? p.FindTypeMapping()?.StructuralComparer;
 
         /// <summary>
         ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to

src/EFCore.Relational/Infrastructure/ModelSnapshot.cs

@@ -4,6 +4,7 @@
 using JetBrains.Annotations;
 using Microsoft.EntityFrameworkCore.Metadata;
 using Microsoft.EntityFrameworkCore.Metadata.Conventions;
+using Microsoft.EntityFrameworkCore.Metadata.Internal;
 
 namespace Microsoft.EntityFrameworkCore.Infrastructure
 {
@@ -16,7 +17,7 @@ public abstract class ModelSnapshot
 
         private IMutableModel CreateModel()
         {
-            var modelBuilder = new ModelBuilder(new ConventionSet());
+            var modelBuilder = new ModelBuilder(new Model());
             BuildModel(modelBuilder);
 
             return modelBuilder.Model;

src/EFCore.Relational/Migrations/Internal/MigrationsModelDiffer.cs

@@ -1814,8 +1814,8 @@ protected virtual void DiffData(
                             var targetValue = entry.GetCurrentValue(targetProperty);
                             var comparer = targetProperty.GetValueComparer() ??
                                            sourceProperty.GetValueComparer() ??
-                                           targetProperty.GetTypeMapping().Comparer ??
-                                           sourceProperty.GetTypeMapping().Comparer;
+                                           targetProperty.FindTypeMapping()?.Comparer ??
+                                           sourceProperty.FindTypeMapping()?.Comparer;
 
                             var modelValuesChanged
                                 = sourceProperty.ClrType.UnwrapNullableType() == targetProperty.ClrType.UnwrapNullableType()

src/EFCore/ChangeTracking/Internal/ChangeDetector.cs

@@ -252,7 +252,7 @@ private void DetectKeyChange(InternalEntityEntry entry, IProperty property)
                 var currentValue = entry[property];
 
                 var comparer = property.GetKeyValueComparer()
-                               ?? property.GetTypeMapping().KeyComparer;
+                               ?? property.FindTypeMapping()?.KeyComparer;
 
                 // Note that mutation of a byte[] key is not supported or detected, but two different instances
                 // of byte[] with the same content must be detected as equal.

src/EFCore/ChangeTracking/Internal/CompositeValueFactory.cs

@@ -133,7 +133,7 @@ protected virtual bool TryCreateFromEntry(
         /// </summary>
         protected static IEqualityComparer<object[]> CreateEqualityComparer([NotNull] IReadOnlyList<IProperty> properties)
         {
-            var comparers = properties.Select(p => p.GetKeyValueComparer() ?? p.GetTypeMapping().KeyComparer).ToList();
+            var comparers = properties.Select(p => p.GetKeyValueComparer() ?? p.FindTypeMapping()?.KeyComparer).ToList();
 
             return comparers.All(c => c != null)
                 ? new CompositeCustomComparer(comparers)

src/EFCore/ChangeTracking/Internal/SimplePrincipalKeyValueFactory.cs

@@ -35,7 +35,7 @@ public SimplePrincipalKeyValueFactory([NotNull] IProperty property)
             _propertyAccessors = _property.GetPropertyAccessors();
 
             var comparer = property.GetKeyValueComparer()
-                           ?? property.GetTypeMapping().KeyComparer;
+                           ?? property.FindTypeMapping()?.KeyComparer;
 
             EqualityComparer
                 = comparer != null

src/EFCore/ChangeTracking/Internal/StateManager.cs

@@ -1067,7 +1067,7 @@ private static bool KeysEqual(InternalEntityEntry entry, IForeignKey fk, Interna
 
         private static bool KeyValuesEqual(IProperty property, object value, object currentValue)
             => (property.GetKeyValueComparer()
-                ?? property.GetTypeMapping().KeyComparer)
+                ?? property.FindTypeMapping()?.KeyComparer)
                ?.Equals(currentValue, value)
                ?? Equals(currentValue, value);
 

src/EFCore/Metadata/Internal/EntityType.cs

@@ -2328,7 +2328,7 @@ public virtual IEnumerable<IDictionary<string, object>> GetSeedData(bool provide
                     {
                         if (propertyBase is IProperty property)
                         {
-                            valueConverter = property.GetTypeMapping().Converter
+                            valueConverter = property.FindTypeMapping()?.Converter
                                              ?? property.GetValueConverter();
                         }
 

src/EFCore/Metadata/Internal/EntityTypeExtensions.cs

@@ -299,7 +299,7 @@ public static PropertyCounts GetCounts([NotNull] this IEntityType entityType)
         /// </summary>
         public static PropertyCounts CalculateCounts([NotNull] this EntityType entityType)
         {
-            Debug.Assert(entityType.Model.ConventionDispatcher == null, "Should not be called on a mutable model");
+            Check.DebugAssert(entityType.Model.IsConventionBasedMutableModel, "Should not be called on a mutable model");
 
             var index = 0;
             var navigationIndex = 0;

src/EFCore/Metadata/Internal/Model.cs

@@ -49,6 +49,8 @@ private readonly SortedDictionary<string, SortedSet<EntityType>> _entityTypesWit
         private readonly Dictionary<string, ConfigurationSource> _ignoredTypeNames
             = new Dictionary<string, ConfigurationSource>(StringComparer.Ordinal);
 
+        private readonly bool _hasNoConventions;
+
         /// <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
@@ -58,6 +60,7 @@ private readonly Dictionary<string, ConfigurationSource> _ignoredTypeNames
         public Model()
             : this(new ConventionSet())
         {
+            _hasNoConventions = true;
         }
 
         /// <summary>
@@ -83,6 +86,16 @@ public Model([NotNull] ConventionSet conventions)
         /// </summary>
         public virtual ConventionDispatcher ConventionDispatcher { [DebuggerStepThrough] get; private set; }
 
+        /// <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 bool IsConventionBasedMutableModel
+            => _hasNoConventions
+               || ConventionDispatcher == null;
+
         /// <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

src/EFCore/ValueGeneration/ValueGeneratorSelector.cs

@@ -73,7 +73,7 @@ private static ValueGenerator CreateFromFactory(IProperty property, IEntityType
 
             if (factory == null)
             {
-                var mapping = property.GetTypeMapping();
+                var mapping = property.FindTypeMapping();
                 factory = mapping?.ValueGeneratorFactory;
 
                 if (factory == null)

src/Shared/Check.cs

@@ -93,5 +93,14 @@ public static IReadOnlyList<T> HasNoNulls<T>(IReadOnlyList<T> value, [InvokerPar
 
             return value;
         }
+
+        [Conditional("DEBUG")]
+        public static void DebugAssert([System.Diagnostics.CodeAnalysis.DoesNotReturnIf(false)] bool condition, string message)
+        {
+            if (!condition)
+            {
+                throw new Exception($"Check.DebugAssert failed: {message}");
+            }
+        }
     }
 }

test/EFCore.SqlServer.FunctionalTests/MigrationsSqlServerTest.cs

@@ -528,6 +528,13 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         b.HasKey("Id");
 
                         b.ToTable("Blogs");
+
+                        b.HasData(
+                            new
+                            {
+                                Id = 1,
+                                Name = "HalfADonkey"
+                            });
                     });
 
                 modelBuilder.Entity(
@@ -1349,6 +1356,15 @@ protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
             => optionsBuilder.UseSqlServer(@"Server=(localdb)\mssqllocaldb;Database=Test;ConnectRetryCount=0");
 
         public DbSet<Blog> Blogs { get; set; }
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            modelBuilder.Entity<Blog>().HasData(
+                new Blog
+                {
+                    Id = 1, Name = "HalfADonkey"
+                });
+        }
     }
 }