Perf: Cache SkipDetectChanges on model as a field

Resolves #22262

src/EFCore/ChangeTracking/ChangeTracker.cs

@@ -220,7 +220,7 @@ public virtual bool HasChanges()
         /// </summary>
         public virtual void DetectChanges()
         {
-            if ((string)_model[CoreAnnotationNames.SkipDetectChangesAnnotation] != "true")
+            if (!((Model)_model).SkipDetectChanges)
             {
                 ChangeDetector.DetectChanges(StateManager);
             }

src/EFCore/ChangeTracking/CollectionEntry.cs

@@ -63,7 +63,7 @@ private void LocalDetectChanges()
                 var context = InternalEntry.StateManager.Context;
 
                 var changeDetector = context.ChangeTracker.AutoDetectChangesEnabled
-                    && (string)context.Model[CoreAnnotationNames.SkipDetectChangesAnnotation] != "true"
+                    && !((Model)context.Model).SkipDetectChanges
                         ? context.GetDependencies().ChangeDetector
                         : null;
 

src/EFCore/ChangeTracking/EntityEntry.cs

@@ -102,7 +102,7 @@ public virtual EntityState State
         /// </summary>
         public virtual void DetectChanges()
         {
-            if ((string)Context.Model[CoreAnnotationNames.SkipDetectChangesAnnotation] != "true")
+            if (!((Model)Context.Model).SkipDetectChanges)
             {
                 Context.GetDependencies().ChangeDetector.DetectChanges(InternalEntry);
             }

src/EFCore/ChangeTracking/Internal/StateManager.cs

@@ -993,7 +993,7 @@ public virtual void CascadeDelete(InternalEntityEntry entry, bool force, IEnumer
             if (!_changeDetectorInitialized)
             {
                 _changeDetector = Context.ChangeTracker.AutoDetectChangesEnabled
-                    && (string)Context.Model[CoreAnnotationNames.SkipDetectChangesAnnotation] != "true"
+                    && !((Model)Context.Model).SkipDetectChanges
                         ? Context.GetDependencies().ChangeDetector
                         : null;
                 _changeDetectorInitialized = true;

src/EFCore/ChangeTracking/ReferenceEntry.cs

@@ -70,7 +70,7 @@ private void LocalDetectChanges()
                 {
                     var context = InternalEntry.StateManager.Context;
                     if (context.ChangeTracker.AutoDetectChangesEnabled
-                        && (string)context.Model[CoreAnnotationNames.SkipDetectChangesAnnotation] != "true")
+                        && !((Model)context.Model).SkipDetectChanges)
                     {
                         context.GetDependencies().ChangeDetector.DetectChanges(target);
                     }

src/EFCore/Metadata/Conventions/ChangeTrackingStrategyConvention.cs

@@ -41,7 +41,10 @@ public virtual void ProcessModelFinalizing(
                 }
             }
 
-            modelBuilder.HasAnnotation(CoreAnnotationNames.SkipDetectChangesAnnotation, "true");
+            if (modelBuilder.Metadata is Model model)
+            {
+                model.SetSkipDetectChanges(true, ConfigurationSource.Convention);
+            }
         }
     }
 }

src/EFCore/Metadata/Internal/CoreAnnotationNames.cs

@@ -257,14 +257,6 @@ public static class CoreAnnotationNames
         /// </summary>
         public const string AmbiguousField = "BackingFieldConvention:AmbiguousField";
 
-        /// <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 string SkipDetectChangesAnnotation = "ChangeDetector.SkipDetectChanges";
-
         /// <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
@@ -315,7 +307,6 @@ public static class CoreAnnotationNames
             AmbiguousNavigations,
             DuplicateServiceProperties,
             AmbiguousField,
-            SkipDetectChangesAnnotation,
             SkipChangeTrackingStrategyValidationAnnotation
         };
     }

src/EFCore/Metadata/Internal/Model.cs

@@ -61,6 +61,9 @@ private readonly Dictionary<string, ConfigurationSource> _ignoredTypeNames
         private readonly Dictionary<Type, ConfigurationSource> _sharedTypes =
             new Dictionary<Type, ConfigurationSource> { { DefaultPropertyBagType, ConfigurationSource.Convention } };
 
+        private bool? _skipDetectChanges;
+        private ConfigurationSource? _skipDetectChangesConfigurationSource;
+
         /// <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
@@ -989,6 +992,41 @@ private IModel MakeReadonly()
         public virtual PropertyInfo FindIndexerPropertyInfo([NotNull] Type type)
             => _indexerPropertyInfoMap.GetOrAdd(type, type.FindIndexerProperty());
 
+        /// <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 SkipDetectChanges
+        {
+            get => _skipDetectChanges ?? false;
+            set => SetSkipDetectChanges(value, ConfigurationSource.Explicit);
+        }
+
+        /// <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? SetSkipDetectChanges(bool? skipDetectChanges, ConfigurationSource configurationSource)
+        {
+            if (skipDetectChanges == null)
+            {
+                _skipDetectChanges = null;
+                _skipDetectChangesConfigurationSource = null;
+
+                return skipDetectChanges;
+            }
+
+            _skipDetectChangesConfigurationSource = configurationSource.Max(_skipDetectChangesConfigurationSource);
+
+            _skipDetectChanges = skipDetectChanges;
+
+            return skipDetectChanges;
+        }
+
         /// <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/Update/Internal/UpdateAdapter.cs

@@ -115,7 +115,7 @@ public virtual IEnumerable<IUpdateEntry> Entries
         /// </summary>
         public virtual void DetectChanges()
         {
-            if ((string)_stateManager.Model[CoreAnnotationNames.SkipDetectChangesAnnotation] != "true")
+            if (!((Model)_stateManager.Model).SkipDetectChanges)
             {
                 _changeDetector.DetectChanges(_stateManager);
             }