Create a read-optimized implementation of IModel

Part of #8258

src/EFCore/Metadata/IMutableAnnotatable.cs

@@ -58,7 +58,7 @@ public interface IMutableAnnotatable : IReadOnlyAnnotatable
         /// </summary>
         /// <param name="annotations"> The annotations to be added. </param>
         void AddAnnotations([NotNull] IEnumerable<IAnnotation> annotations)
-            => Annotatable.AddAnnotations(this, annotations);
+            => AnnotatableBase.AddAnnotations((AnnotatableBase)this, annotations);
 
         /// <summary>
         ///     Sets the annotation stored under the given name. Overwrites the existing annotation if an

src/EFCore/Metadata/Internal/EntityTypeExtensions.cs

@@ -214,7 +214,7 @@ public static PropertyCounts GetCounts([NotNull] this IEntityType entityType)
         ///     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 PropertyCounts CalculateCounts([NotNull] this EntityType entityType)
+        public static PropertyCounts CalculateCounts([NotNull] this IRuntimeEntityType entityType)
         {
             var index = 0;
             var navigationIndex = 0;
@@ -243,13 +243,13 @@ public static PropertyCounts CalculateCounts([NotNull] this EntityType entityTyp
                     relationshipIndex: property.IsKey() || property.IsForeignKey() ? relationshipIndex++ : -1,
                     storeGenerationIndex: property.MayBeStoreGenerated() ? storeGenerationIndex++ : -1);
 
-                property.PropertyIndexes = indexes;
+                ((IRuntimePropertyBase)property).PropertyIndexes = indexes;
             }
 
             var isNotifying = entityType.GetChangeTrackingStrategy() != ChangeTrackingStrategy.Snapshot;
 
             foreach (var navigation in entityType.GetDeclaredNavigations()
-                .Union<PropertyBase>(entityType.GetDeclaredSkipNavigations()))
+                .Union<IPropertyBase>(entityType.GetDeclaredSkipNavigations()))
             {
                 var indexes = new PropertyIndexes(
                     index: navigationIndex++,
@@ -258,7 +258,7 @@ public static PropertyCounts CalculateCounts([NotNull] this EntityType entityTyp
                     relationshipIndex: ((IReadOnlyNavigationBase)navigation).IsCollection && isNotifying ? -1 : relationshipIndex++,
                     storeGenerationIndex: -1);
 
-                navigation.PropertyIndexes = indexes;
+                ((IRuntimePropertyBase)navigation).PropertyIndexes = indexes;
             }
 
             foreach (var serviceProperty in entityType.GetDeclaredServiceProperties())
@@ -270,7 +270,7 @@ public static PropertyCounts CalculateCounts([NotNull] this EntityType entityTyp
                     relationshipIndex: -1,
                     storeGenerationIndex: -1);
 
-                serviceProperty.PropertyIndexes = indexes;
+                ((IRuntimePropertyBase)serviceProperty).PropertyIndexes = indexes;
             }
 
             return new PropertyCounts(

src/EFCore/Metadata/Internal/ForeignKey.cs

@@ -759,8 +759,14 @@ public virtual DeleteBehavior DeleteBehavior
             return DeleteBehavior;
         }
 
-        private static DeleteBehavior DefaultDeleteBehavior
-            => DeleteBehavior.ClientSetNull;
+        /// <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 const DeleteBehavior DefaultDeleteBehavior
+            = DeleteBehavior.ClientSetNull;
 
         /// <summary>
         ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to

src/EFCore/Metadata/Internal/IRuntimeEntityType.cs

@@ -80,5 +80,13 @@ public interface IRuntimeEntityType : IEntityType
         ///     doing so can result in application failures when updating to a new Entity Framework Core release.
         /// </summary>
         Func<MaterializationContext, object> InstanceFactory { get; }
+
+        /// <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>
+        InstantiationBinding? ServiceOnlyConstructorBinding { get; }
     }
 }

src/EFCore/Metadata/Internal/IRuntimePropertyBase.cs

@@ -1,6 +1,8 @@
 // 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;
+
 #nullable enable
 
 namespace Microsoft.EntityFrameworkCore.Metadata.Internal
@@ -43,7 +45,7 @@ public interface IRuntimePropertyBase : IPropertyBase
         ///     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>
-        PropertyIndexes PropertyIndexes { get; }
+        PropertyIndexes PropertyIndexes { get; [param: NotNull] set; }
 
         /// <summary>
         ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to

src/EFCore/Metadata/Internal/Model.cs

@@ -7,7 +7,6 @@
 using System.Diagnostics;
 using System.Linq;
 using System.Reflection;
-using System.Threading;
 using JetBrains.Annotations;
 using Microsoft.EntityFrameworkCore.Diagnostics;
 using Microsoft.EntityFrameworkCore.Infrastructure;
@@ -743,6 +742,14 @@ public virtual PropertyAccessMode GetPropertyAccessMode()
             => (PropertyAccessMode?)this[CoreAnnotationNames.PropertyAccessMode]
                 ?? PropertyAccessMode.PreferField;
 
+        /// <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 const PropertyAccessMode DefaultPropertyAccessMode = PropertyAccessMode.PreferField;
+
         /// <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/Metadata/Internal/PropertyBase.cs

@@ -311,7 +311,6 @@ public static bool IsCompatible(
         ///     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>
-        [CA.AllowNull]
         public virtual PropertyIndexes PropertyIndexes
         {
             get
@@ -324,21 +323,7 @@ public virtual PropertyIndexes PropertyIndexes
                         var _ = (property.DeclaringType as EntityType)?.Counts;
                     });
 
-            [param: CanBeNull]
-            set
-            {
-                if (value == null)
-                {
-                    EnsureMutable();
-                    // This path should only kick in when the model is still mutable and therefore access does not need
-                    // to be thread-safe.
-                    _indexes = null;
-                }
-                else
-                {
-                    NonCapturingLazyInitializer.EnsureInitialized(ref _indexes, value);
-                }
-            }
+            set => NonCapturingLazyInitializer.EnsureInitialized(ref _indexes, value);
         }
 
         /// <summary>

src/EFCore/Metadata/Internal/PropertyNameComparer.cs

@@ -17,15 +17,15 @@ namespace Microsoft.EntityFrameworkCore.Metadata.Internal
     /// </summary>
     public sealed class PropertyNameComparer : IComparer<string>
     {
-        private readonly EntityType _entityType;
+        private readonly IReadOnlyEntityType _entityType;
 
         /// <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 PropertyNameComparer([NotNull] EntityType entityType)
+        public PropertyNameComparer([NotNull] IReadOnlyEntityType entityType)
         {
             _entityType = entityType;
         }

src/EFCore/Metadata/Internal/SkipNavigationComparer.cs

@@ -14,7 +14,7 @@ namespace Microsoft.EntityFrameworkCore.Metadata.Internal
     ///     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 sealed class SkipNavigationComparer : IComparer<SkipNavigation>
+    public sealed class SkipNavigationComparer : IComparer<IReadOnlySkipNavigation>
     {
         private SkipNavigationComparer()
         {
@@ -34,7 +34,7 @@ private SkipNavigationComparer()
         ///     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 int Compare(SkipNavigation? x, SkipNavigation? y)
+        public int Compare(IReadOnlySkipNavigation? x, IReadOnlySkipNavigation? y)
             => (x, y) switch
             {
                 (not null, null) => 1,