Move ConstructionBinding from an annotation to an interface

Part of #19213

src/EFCore.Cosmos/Infrastructure/Internal/CosmosDbOptionExtension.cs

@@ -181,8 +181,8 @@ public virtual CosmosOptionsExtension WithConnectionString([CanBeNull] string? c
         ///     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 string? DatabaseName
-            => _databaseName;
+        public virtual string DatabaseName
+            => _databaseName!;
 
         /// <summary>
         ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to

src/EFCore.Proxies/Proxies/Internal/IProxyFactory.cs

@@ -49,7 +49,7 @@ object CreateProxy(
         /// </summary>
         Type CreateProxyType(
             [NotNull] ProxiesOptionsExtension options,
-            [NotNull] IEntityType entityType);
+            [NotNull] IReadOnlyEntityType entityType);
 
         /// <summary>
         ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to

src/EFCore.Proxies/Proxies/Internal/ProxyFactory.cs

@@ -62,10 +62,10 @@ public virtual object Create(
         /// </summary>
         public virtual Type CreateProxyType(
             ProxiesOptionsExtension options,
-            IEntityType entityType)
+            IReadOnlyEntityType entityType)
             => _generator.ProxyBuilder.CreateClassProxyType(
                 entityType.ClrType,
-                GetInterfacesToProxy(options, entityType),
+                GetInterfacesToProxy(options, entityType.ClrType),
                 ProxyGenerationOptions.Default);
 
         /// <summary>
@@ -100,7 +100,7 @@ private object CreateLazyLoadingProxy(
             object[] constructorArguments)
             => _generator.CreateClassProxy(
                 entityType.ClrType,
-                GetInterfacesToProxy(options, entityType),
+                GetInterfacesToProxy(options, entityType.ClrType),
                 ProxyGenerationOptions.Default,
                 constructorArguments,
                 GetNotifyChangeInterceptors(options, entityType, new LazyLoadingInterceptor(entityType, loader)));
@@ -143,14 +143,14 @@ private object CreateProxy(
             object[] constructorArguments)
             => _generator.CreateClassProxy(
                 entityType.ClrType,
-                GetInterfacesToProxy(options, entityType),
+                GetInterfacesToProxy(options, entityType.ClrType),
                 ProxyGenerationOptions.Default,
                 constructorArguments,
                 GetNotifyChangeInterceptors(options, entityType));
 
         private Type[] GetInterfacesToProxy(
             ProxiesOptionsExtension options,
-            IEntityType entityType)
+            Type type)
         {
             var interfacesToProxy = new List<Type>();
 
@@ -161,12 +161,12 @@ private Type[] GetInterfacesToProxy(
 
             if (options.UseChangeTrackingProxies)
             {
-                if (!_notifyPropertyChangedInterface.IsAssignableFrom(entityType.ClrType))
+                if (!_notifyPropertyChangedInterface.IsAssignableFrom(type))
                 {
                     interfacesToProxy.Add(_notifyPropertyChangedInterface);
                 }
 
-                if (!_notifyPropertyChangingInterface.IsAssignableFrom(entityType.ClrType))
+                if (!_notifyPropertyChangingInterface.IsAssignableFrom(type))
                 {
                     interfacesToProxy.Add(_notifyPropertyChangingInterface);
                 }

src/EFCore/Infrastructure/ModelRuntimeInitializer.cs

@@ -4,6 +4,7 @@
 using JetBrains.Annotations;
 using Microsoft.EntityFrameworkCore.Diagnostics;
 using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Metadata.Internal;
 using Microsoft.EntityFrameworkCore.Utilities;
 using Microsoft.Extensions.DependencyInjection;
 
@@ -56,12 +57,19 @@ public virtual IModel Initialize(
             if (model.SetModelDependencies(Dependencies.ModelDependencies))
             {
                 InitializeModel(model, preValidation: true);
+
                 if (validationLogger != null
-                    && model is IMutableModel)
+                    && model is IConventionModel)
                 {
                     Dependencies.ModelValidator.Validate(model, validationLogger);
                 }
+
                 InitializeModel(model, preValidation: false);
+
+                if (model is Model mutableModel)
+                {
+                    model = mutableModel.OnModelFinalized();
+                }
             }
 
             return model;

src/EFCore/Infrastructure/ModelValidator.cs

@@ -843,8 +843,7 @@ protected virtual void ValidateFieldMapping(
                         .Concat(entityType.GetDeclaredNavigations())
                         .Where(p => !p.IsShadowProperty() && !p.IsIndexerProperty()));
 
-                var constructorBinding = (InstantiationBinding?)entityType[CoreAnnotationNames.ConstructorBinding];
-
+                var constructorBinding = entityType.ConstructorBinding;
                 if (constructorBinding != null)
                 {
                     foreach (var consumedProperty in constructorBinding.ParameterBindings.SelectMany(p => p.ConsumedProperties))

src/EFCore/Infrastructure/SingletonModelDependencies.cs

@@ -55,16 +55,32 @@ public sealed record SingletonModelDependencies
         /// </summary>
         [EntityFrameworkInternal]
         public SingletonModelDependencies(
-            [NotNull] ITypeMappingSource typeMappingSource)
+            [NotNull] ITypeMappingSource typeMappingSource,
+            [NotNull] IConstructorBindingFactory constructorBindingFactory,
+            [NotNull] IParameterBindingFactories parameterBindingFactories)
         {
             Check.NotNull(typeMappingSource, nameof(typeMappingSource));
+            Check.NotNull(constructorBindingFactory, nameof(constructorBindingFactory));
+            Check.NotNull(parameterBindingFactories, nameof(parameterBindingFactories));
 
             TypeMappingSource = typeMappingSource;
+            ConstructorBindingFactory = constructorBindingFactory;
+            ParameterBindingFactories = parameterBindingFactories;
         }
 
         /// <summary>
         ///     The type mapper.
         /// </summary>
         public ITypeMappingSource TypeMappingSource { get; [param: NotNull] init; }
+
+        /// <summary>
+        ///     The constructor binding factory.
+        /// </summary>
+        public IConstructorBindingFactory ConstructorBindingFactory { get; [param: NotNull] init; }
+
+        /// <summary>
+        ///     The parameter binding factories.
+        /// </summary>
+        public IParameterBindingFactories ParameterBindingFactories { get; [param: NotNull] init; }
     }
 }

src/EFCore/Metadata/Conventions/ConstructorBindingConvention.cs

@@ -1,13 +1,7 @@
 // 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 System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
 using JetBrains.Annotations;
-using Microsoft.EntityFrameworkCore.Diagnostics;
-using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 using Microsoft.EntityFrameworkCore.Metadata.Conventions.Infrastructure;
 using Microsoft.EntityFrameworkCore.Metadata.Internal;
@@ -46,122 +40,18 @@ public virtual void ProcessModelFinalizing(
             IConventionModelBuilder modelBuilder,
             IConventionContext<IConventionModelBuilder> context)
         {
-            foreach (var entityType in modelBuilder.Metadata.GetEntityTypes())
+            foreach (EntityType entityType in modelBuilder.Metadata.GetEntityTypes())
             {
-                if (entityType.ClrType?.IsAbstract == false
-                    && entityType.Builder.CanSetAnnotation(CoreAnnotationNames.ConstructorBinding, null))
+                if (!entityType.ClrType.IsAbstract
+                    && ConfigurationSource.Convention.Overrides(entityType.GetConstructorBindingConfigurationSource()))
                 {
-                    var maxServiceParams = 0;
-                    var maxServiceOnlyParams = 0;
-                    var minPropertyParams = int.MaxValue;
-                    var foundBindings = new List<InstantiationBinding>();
-                    var foundServiceOnlyBindings = new List<InstantiationBinding>();
-                    var bindingFailures = new List<IEnumerable<ParameterInfo>>();
+                    Dependencies.ConstructorBindingFactory.GetBindings(
+                        (IMutableEntityType)entityType, out var constructorBinding, out var serviceOnlyBinding);
 
-                    foreach (var constructor in entityType.ClrType.GetTypeInfo()
-                        .DeclaredConstructors
-                        .Where(c => !c.IsStatic))
-                    {
-                        // Trying to find the constructor with the most service properties
-                        // followed by the least scalar property parameters
-                        if (Dependencies.ConstructorBindingFactory.TryBindConstructor(
-                            entityType, constructor, out var binding, out var failures))
-                        {
-                            var serviceParamCount = binding.ParameterBindings.OfType<ServiceParameterBinding>().Count();
-                            var propertyParamCount = binding.ParameterBindings.Count - serviceParamCount;
-
-                            if (propertyParamCount == 0)
-                            {
-                                if (serviceParamCount == maxServiceOnlyParams)
-                                {
-                                    foundServiceOnlyBindings.Add(binding);
-                                }
-                                else if (serviceParamCount > maxServiceOnlyParams)
-                                {
-                                    foundServiceOnlyBindings.Clear();
-                                    foundServiceOnlyBindings.Add(binding);
-
-                                    maxServiceOnlyParams = serviceParamCount;
-                                }
-                            }
-
-                            if (serviceParamCount == maxServiceParams
-                                && propertyParamCount == minPropertyParams)
-                            {
-                                foundBindings.Add(binding);
-                            }
-                            else if (serviceParamCount > maxServiceParams)
-                            {
-                                foundBindings.Clear();
-                                foundBindings.Add(binding);
-
-                                maxServiceParams = serviceParamCount;
-                                minPropertyParams = propertyParamCount;
-                            }
-                            else if (propertyParamCount < minPropertyParams)
-                            {
-                                foundBindings.Clear();
-                                foundBindings.Add(binding);
-
-                                maxServiceParams = serviceParamCount;
-                                minPropertyParams = propertyParamCount;
-                            }
-                        }
-                        else
-                        {
-                            bindingFailures.Add(failures);
-                        }
-                    }
-
-                    if (foundBindings.Count == 0)
-                    {
-                        var constructorErrors = bindingFailures.SelectMany(f => f)
-                            .GroupBy(f => (ConstructorInfo)f.Member)
-                            .Select(
-                                x => CoreStrings.ConstructorBindingFailed(
-                                    string.Join("', '", x.Select(f => f.Name)),
-                                    entityType.DisplayName()
-                                    + "("
-                                    + string.Join(
-                                        ", ", x.Key.GetParameters().Select(
-                                            y => y.ParameterType.ShortDisplayName() + " " + y.Name)
-                                    )
-                                    + ")"
-                                )
-                            );
-
-                        throw new InvalidOperationException(
-                            CoreStrings.ConstructorNotFound(
-                                entityType.DisplayName(),
-                                string.Join("; ", constructorErrors)));
-                    }
-
-                    if (foundBindings.Count > 1)
-                    {
-                        throw new InvalidOperationException(
-                            CoreStrings.ConstructorConflict(
-                                FormatConstructorString(entityType, foundBindings[0]),
-                                FormatConstructorString(entityType, foundBindings[1])));
-                    }
-
-                    entityType.Builder.HasAnnotation(
-                        CoreAnnotationNames.ConstructorBinding,
-                        foundBindings[0]);
-
-                    if (foundServiceOnlyBindings.Count == 1)
-                    {
-                        entityType.Builder.HasAnnotation(
-                            CoreAnnotationNames.ServiceOnlyConstructorBinding,
-                            foundServiceOnlyBindings[0]);
-                    }
+                    entityType.Builder.HasConstructorBinding(constructorBinding, ConfigurationSource.Convention);
+                    entityType.Builder.HasServiceOnlyConstructorBinding(serviceOnlyBinding, ConfigurationSource.Convention);
                 }
             }
         }
-
-        private static string FormatConstructorString(IReadOnlyEntityType entityType, InstantiationBinding binding)
-            => entityType.ClrType.ShortDisplayName()
-                + "("
-                + string.Join(", ", binding.ParameterBindings.Select(b => b.ParameterType.ShortDisplayName()))
-                + ")";
     }
 }

src/EFCore/Metadata/Conventions/Infrastructure/ProviderConventionSetBuilderDependencies.cs

@@ -94,13 +94,13 @@ public ProviderConventionSetBuilderDependencies(
             Check.NotNull(validator, nameof(validator));
 
             TypeMappingSource = typeMappingSource;
+            ConstructorBindingFactory = constructorBindingFactory;
             ParameterBindingFactories = parameterBindingFactories;
             MemberClassifier = memberClassifier;
-            ConstructorBindingFactory = constructorBindingFactory;
             Logger = logger;
+            ValidationLogger = validationLogger;
             SetFinder = setFinder;
             _currentContext = currentContext;
-            ValidationLogger = validationLogger;
 #pragma warning disable CS0618 // Type or member is obsolete
             ModelValidator = validator;
 #pragma warning restore CS0618 // Type or member is obsolete

src/EFCore/Metadata/Conventions/Internal/ConventionDispatcher.ImmediateConventionScope.cs

@@ -85,16 +85,6 @@ public IConventionModelBuilder OnModelFinalizing([NotNull] IConventionModelBuild
                 return modelBuilder;
             }
 
-            public IModel OnModelFinalized([NotNull] IModel model)
-            {
-                foreach (var modelConvention in _conventionSet.ModelFinalizedConventions)
-                {
-                    model = modelConvention.ProcessModelFinalized(model);
-                }
-
-                return model;
-            }
-
             public IConventionModelBuilder OnModelInitialized([NotNull] IConventionModelBuilder modelBuilder)
             {
                 using (_dispatcher.DelayConventions())

src/EFCore/Metadata/Conventions/Internal/ConventionDispatcher.cs

@@ -66,15 +66,6 @@ public virtual IConventionModelBuilder OnModelInitialized([NotNull] IConventionM
         public virtual IConventionModelBuilder OnModelFinalizing([NotNull] IConventionModelBuilder modelBuilder)
             => _immediateConventionScope.OnModelFinalizing(modelBuilder);
 
-        /// <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 IModel OnModelFinalized([NotNull] IModel model)
-            => _immediateConventionScope.OnModelFinalized(model);
-
         /// <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/IConstructorBindingFactory.cs

@@ -24,6 +24,42 @@ namespace Microsoft.EntityFrameworkCore.Metadata
     /// </summary>
     public interface IConstructorBindingFactory
     {
+        /// <summary>
+        ///     Create a <see cref="InstantiationBinding" /> for the constructor with most parameters and
+        ///     the constructor with only service property parameters.
+        /// </summary>
+        /// <param name="entityType"> The entity type. </param>
+        /// <param name="constructorBinding"> The binding for the constructor with most parameters. </param>
+        /// <param name="serviceOnlyBinding"> The binding for the constructor with only service property parameters. </param>
+        void GetBindings(
+            [NotNull] IConventionEntityType entityType,
+            [NotNull] out InstantiationBinding constructorBinding,
+            [NotNull] out InstantiationBinding? serviceOnlyBinding);
+
+        /// <summary>
+        ///     Create a <see cref="InstantiationBinding" /> for the constructor with most parameters and
+        ///     the constructor with only service property parameters.
+        /// </summary>
+        /// <param name="entityType"> The entity type. </param>
+        /// <param name="constructorBinding"> The binding for the constructor with most parameters. </param>
+        /// <param name="serviceOnlyBinding"> The binding for the constructor with only service property parameters. </param>
+        void GetBindings(
+            [NotNull] IMutableEntityType entityType,
+            [NotNull] out InstantiationBinding constructorBinding,
+            [NotNull] out InstantiationBinding? serviceOnlyBinding);
+
+        /// <summary>
+        ///     Create a <see cref="InstantiationBinding" /> for the constructor with most parameters and
+        ///     the constructor with only service property parameters.
+        /// </summary>
+        /// <param name="entityType"> The entity type. </param>
+        /// <param name="constructorBinding"> The binding for the constructor with most parameters. </param>
+        /// <param name="serviceOnlyBinding"> The binding for the constructor with only service property parameters. </param>
+        void GetBindings(
+            [NotNull] IReadOnlyEntityType entityType,
+            [NotNull] out InstantiationBinding constructorBinding,
+            [NotNull] out InstantiationBinding? serviceOnlyBinding);
+
         /// <summary>
         ///     Attempts to create a <see cref="InstantiationBinding" /> for the given entity type and
         ///     <see cref="ConstructorInfo" />

src/EFCore/Metadata/IConventionEntityType.cs

@@ -102,9 +102,9 @@ void HasNoKey(bool? keyless, bool fromDataAnnotation = false)
             => SetIsKeyless(keyless, fromDataAnnotation);
 
         /// <summary>
-        ///     Returns the configuration source for the IsKeyless property.
+        ///     Returns the configuration source for <see cref="IsKeyless"/>.
         /// </summary>
-        /// <returns> The configuration source for the IsKeyless property. </returns>
+        /// <returns> The configuration source for <see cref="IsKeyless"/>. </returns>
         ConfigurationSource? GetIsKeylessConfigurationSource();
 
         /// <summary>