Make parameter binding API public

This allows others to build proxies without using internal code.

Fixes #14554 #15252

Internal code is still being used for conventions.

src/EFCore.Proxies/Proxies/Internal/ProxiesConventionSetCustomizer.cs

@@ -4,9 +4,9 @@
 using JetBrains.Annotations;
 using Microsoft.EntityFrameworkCore.Diagnostics;
 using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
 using Microsoft.EntityFrameworkCore.Metadata.Conventions;
 using Microsoft.EntityFrameworkCore.Metadata.Conventions.Infrastructure;
-using Microsoft.EntityFrameworkCore.Metadata.Internal;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace Microsoft.EntityFrameworkCore.Proxies.Internal
@@ -32,6 +32,7 @@ public class ProxiesConventionSetCustomizer : IConventionSetCustomizer
         private readonly IConstructorBindingFactory _constructorBindingFactory;
         private readonly IProxyFactory _proxyFactory;
         private readonly IDiagnosticsLogger<DbLoggerCategory.Model> _logger;
+        private readonly LazyLoaderParameterBindingFactoryDependencies _lazyLoaderParameterBindingFactoryDependencies;
 
         /// <summary>
         ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
@@ -43,12 +44,14 @@ public ProxiesConventionSetCustomizer(
             [NotNull] IDbContextOptions options,
             [NotNull] IConstructorBindingFactory constructorBindingFactory,
             [NotNull] IProxyFactory proxyFactory,
-            [NotNull] IDiagnosticsLogger<DbLoggerCategory.Model> logger)
+            [NotNull] IDiagnosticsLogger<DbLoggerCategory.Model> logger,
+            [NotNull] LazyLoaderParameterBindingFactoryDependencies lazyLoaderParameterBindingFactoryDependencies)
         {
             _options = options;
             _constructorBindingFactory = constructorBindingFactory;
             _proxyFactory = proxyFactory;
             _logger = logger;
+            _lazyLoaderParameterBindingFactoryDependencies = lazyLoaderParameterBindingFactoryDependencies;
         }
 
         /// <summary>
@@ -61,6 +64,7 @@ public virtual ConventionSet ModifyConventions(ConventionSet conventionSet)
         {
             conventionSet.ModelBuiltConventions.Add(
                 new ProxyBindingRewriter(
+                    _lazyLoaderParameterBindingFactoryDependencies,
                     _proxyFactory,
                     _constructorBindingFactory,
                     _logger,

src/EFCore.Proxies/Proxies/Internal/ProxiesOptionsExtension.cs

@@ -9,7 +9,6 @@
 using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Internal;
 using Microsoft.EntityFrameworkCore.Metadata.Conventions.Infrastructure;
-using Microsoft.EntityFrameworkCore.Metadata.Conventions.Internal;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace Microsoft.EntityFrameworkCore.Proxies.Internal

src/EFCore.Proxies/Proxies/Internal/ProxyBindingRewriter.cs

@@ -30,6 +30,7 @@ private static readonly PropertyInfo _lazyLoaderProperty
             = typeof(IProxyLazyLoader).GetProperty(nameof(IProxyLazyLoader.LazyLoader));
 
         private readonly ConstructorBindingConvention _directBindingConvention;
+        private readonly LazyLoaderParameterBindingFactoryDependencies _lazyLoaderParameterBindingFactoryDependencies;
         private readonly IProxyFactory _proxyFactory;
         private readonly ProxiesOptionsExtension _options;
 
@@ -40,12 +41,14 @@ private static readonly PropertyInfo _lazyLoaderProperty
         ///     doing so can result in application failures when updating to a new Entity Framework Core release.
         /// </summary>
         public ProxyBindingRewriter(
+            [NotNull] LazyLoaderParameterBindingFactoryDependencies lazyLoaderParameterBindingFactoryDependencies,
             [NotNull] IProxyFactory proxyFactory,
             [NotNull] IConstructorBindingFactory bindingFactory,
             [NotNull] IDiagnosticsLogger<DbLoggerCategory.Model> logger,
             [CanBeNull] ProxiesOptionsExtension options)
         {
             _directBindingConvention = new ConstructorBindingConvention(bindingFactory, logger);
+            _lazyLoaderParameterBindingFactoryDependencies = lazyLoaderParameterBindingFactoryDependencies;
             _proxyFactory = proxyFactory;
             _options = options;
         }
@@ -83,7 +86,7 @@ public virtual InternalModelBuilder Apply(InternalModelBuilder modelBuilder)
                         {
                             serviceProperty = entityType.AddServiceProperty(_lazyLoaderProperty, ConfigurationSource.Convention);
                             serviceProperty.SetParameterBinding(
-                                (ServiceParameterBinding)new LazyLoaderParameterBindingFactory().Bind(
+                                (ServiceParameterBinding)new LazyLoaderParameterBindingFactory(_lazyLoaderParameterBindingFactoryDependencies).Bind(
                                     entityType,
                                     typeof(ILazyLoader),
                                     nameof(IProxyLazyLoader.LazyLoader)));
@@ -104,7 +107,7 @@ public virtual InternalModelBuilder Apply(InternalModelBuilder modelBuilder)
                                 new List<ParameterBinding>
                                 {
                                     new EntityTypeParameterBinding(),
-                                    new DefaultServiceParameterBinding(typeof(ILazyLoader), typeof(ILazyLoader), serviceProperty),
+                                    new DependencyInjectionParameterBinding(typeof(ILazyLoader), typeof(ILazyLoader), serviceProperty),
                                     new ObjectArrayParameterBinding(binding.ParameterBindings)
                                 },
                                 proxyType);

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

@@ -5,7 +5,6 @@
 using Castle.DynamicProxy;
 using Microsoft.EntityFrameworkCore.Diagnostics;
 using Microsoft.EntityFrameworkCore.Infrastructure;
-using Microsoft.EntityFrameworkCore.Internal;
 using Microsoft.EntityFrameworkCore.Metadata;
 
 namespace Microsoft.EntityFrameworkCore.Proxies.Internal

src/EFCore.Proxies/ProxiesServiceCollectionExtensions.cs

@@ -4,7 +4,6 @@
 using JetBrains.Annotations;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Metadata.Conventions.Infrastructure;
-using Microsoft.EntityFrameworkCore.Metadata.Conventions.Internal;
 using Microsoft.EntityFrameworkCore.Proxies.Internal;
 using Microsoft.EntityFrameworkCore.Utilities;
 

src/EFCore/Infrastructure/EntityFrameworkServicesBuilder.cs

@@ -315,6 +315,7 @@ public virtual EntityFrameworkServicesBuilder TryAddCoreServices()
                 .TryAddSingleton<DiagnosticSource>(new DiagnosticListener(DbLoggerCategory.Name));
 
             ServiceCollectionMap.GetInfrastructure()
+                .AddDependencySingleton<LazyLoaderParameterBindingFactoryDependencies>()
                 .AddDependencySingleton<DatabaseProviderDependencies>()
                 .AddDependencySingleton<ResultOperatorHandlerDependencies>()
                 .AddDependencySingleton<ModelSourceDependencies>()

src/EFCore/Metadata/ConstructorBinding.cs

@@ -0,0 +1,49 @@
+// 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.Expressions;
+using JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore.Utilities;
+
+namespace Microsoft.EntityFrameworkCore.Metadata
+{
+    /// <summary>
+    ///     Defines how to create an entity instance through the binding of EF model properties to, for
+    ///     example, constructor parameters or parameters of a factory method.
+    /// </summary>
+    public abstract class ConstructorBinding
+    {
+        /// <summary>
+        ///     Creates a new <see cref="ConstructorBinding" /> instance.
+        /// </summary>
+        /// <param name="parameterBindings"> The parameter bindings to use. </param>
+        protected ConstructorBinding(
+            [NotNull] IReadOnlyList<ParameterBinding> parameterBindings)
+        {
+            Check.NotNull(parameterBindings, nameof(parameterBindings));
+
+            ParameterBindings = parameterBindings;
+        }
+
+        /// <summary>
+        ///     Creates an expression tree that represents creating an entity instance from the given binding
+        ///     information. For example, this might be a <see cref="NewExpression" /> to call a constructor,
+        ///     or a <see cref="MethodCallExpression" /> to call a factory method.
+        /// </summary>
+        /// <param name="bindingInfo"> Information needed to create the expression. </param>
+        /// <returns> The expression tree. </returns>
+        public abstract Expression CreateConstructorExpression(ParameterBindingInfo bindingInfo);
+
+        /// <summary>
+        ///     The collection of <see cref="ParameterBinding" /> instances used.
+        /// </summary>
+        public virtual IReadOnlyList<ParameterBinding> ParameterBindings { get; }
+
+        /// <summary>
+        ///     The type that will be created from the expression tree created for this binding.
+        /// </summary>
+        public abstract Type RuntimeType { get; }
+    }
+}

src/EFCore/Metadata/ContextParameterBinding.cs

@@ -0,0 +1,54 @@
+// 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.Linq.Expressions;
+using JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore.Storage;
+using Microsoft.EntityFrameworkCore.Utilities;
+
+namespace Microsoft.EntityFrameworkCore.Metadata
+{
+    /// <summary>
+    ///     Describes the binding of a <see cref="DbContext"/>, which may or may not also have and associated
+    ///     <see cref="IServiceProperty" />, to a parameter in a constructor, factory method, or similar.
+    /// </summary>
+    public class ContextParameterBinding : ServiceParameterBinding
+    {
+        /// <summary>
+        ///     Creates a new <see cref="ServiceParameterBinding" /> instance for the given service type.
+        /// </summary>
+        /// <param name="contextType"> The <see cref="DbContext"/> CLR type. </param>
+        /// <param name="serviceProperty"> The associated <see cref="IServiceProperty" />, or null. </param>
+        public ContextParameterBinding(
+            [NotNull] Type contextType,
+            [CanBeNull] IPropertyBase serviceProperty = null)
+            : base(contextType, contextType, serviceProperty)
+        {
+        }
+
+        /// <summary>
+        ///     Creates an expression tree representing the binding of the value of a property from a
+        ///     materialization expression to a parameter of the constructor, factory method, etc.
+        /// </summary>
+        /// <param name="materializationExpression"> The expression representing the materialization context. </param>
+        /// <param name="entityTypeExpression"> The expression representing the <see cref="IEntityType" /> constant. </param>
+        /// <returns> The expression tree. </returns>
+        public override Expression BindToParameter(
+            Expression materializationExpression,
+            Expression entityTypeExpression)
+        {
+            Check.NotNull(materializationExpression, nameof(materializationExpression));
+            Check.NotNull(entityTypeExpression, nameof(entityTypeExpression));
+
+            var propertyExpression
+                = Expression.Property(
+                    materializationExpression,
+                    MaterializationContext.ContextProperty);
+
+            return ServiceType != typeof(DbContext)
+                ? (Expression)Expression.TypeAs(propertyExpression, ServiceType)
+                : propertyExpression;
+        }
+    }
+}

src/EFCore/Metadata/CoreAnnotationNames.cs

@@ -51,7 +51,7 @@ public static class CoreAnnotationNames
         public const string OwnedTypes = "OwnedTypes";
 
         /// <summary>
-        ///     Indicates the <see cref="Internal.ConstructorBinding" /> to use for the annotated item.
+        ///     Indicates the <see cref="Metadata.ConstructorBinding" /> to use for the annotated item.
         /// </summary>
         public const string ConstructorBinding = "ConstructorBinding";
 

src/EFCore/Metadata/DependencyInjectionMethodParameterBinding.cs

@@ -0,0 +1,91 @@
+// 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.Linq.Expressions;
+using System.Reflection;
+using JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore.Utilities;
+
+namespace Microsoft.EntityFrameworkCore.Metadata
+{
+    /// <summary>
+    ///     Describes the binding from a method on an EF internal dependency injection service, which may or may not
+    ///     also have and associated <see cref="IServiceProperty" />, to a parameter in a constructor,
+    ///     factory method, or similar.
+    /// </summary>
+    public class DependencyInjectionMethodParameterBinding : DependencyInjectionParameterBinding
+    {
+        /// <summary>
+        ///     Creates a new <see cref="DependencyInjectionParameterBinding" /> instance for the given method
+        ///     of the given service type.
+        /// </summary>
+        /// <param name="parameterType"> The parameter CLR type. </param>
+        /// <param name="serviceType"> The service CLR types, as resolved from dependency injection </param>
+        /// <param name="method"> The method of the service to bind to. </param>
+        /// <param name="serviceProperty"> The associated <see cref="IServiceProperty" />, or null. </param>
+        public DependencyInjectionMethodParameterBinding(
+            [NotNull] Type parameterType,
+            [NotNull] Type serviceType,
+            [NotNull] MethodInfo method,
+            [CanBeNull] IPropertyBase serviceProperty = null)
+            : base(parameterType, serviceType, serviceProperty)
+        {
+            Check.NotNull(method, nameof(method));
+
+            Method = method;
+        }
+
+        /// <summary>
+        ///     The method being bound to, as defined on the dependency injection service interface.
+        /// </summary>
+        public virtual MethodInfo Method { get; }
+
+        /// <summary>
+        ///     Creates an expression tree representing the binding of the value of a property from a
+        ///     materialization expression to a parameter of the constructor, factory method, etc.
+        /// </summary>
+        /// <param name="materializationExpression"> The expression representing the materialization context. </param>
+        /// <param name="entityTypeExpression"> The expression representing the <see cref="IEntityType" /> constant. </param>
+        /// <returns> The expression tree. </returns>
+        public override Expression BindToParameter(
+            Expression materializationExpression,
+            Expression entityTypeExpression)
+        {
+            Check.NotNull(materializationExpression, nameof(materializationExpression));
+            Check.NotNull(entityTypeExpression, nameof(entityTypeExpression));
+
+            var parameters = Method.GetParameters().Select(
+                (p, i) => Expression.Parameter(p.ParameterType, "param" + i)).ToArray();
+
+            var serviceVariable = Expression.Variable(ServiceType, "service");
+            var delegateVariable = Expression.Variable(ParameterType, "delegate");
+
+            return Expression.Block(
+                new[]
+                {
+                    serviceVariable, delegateVariable
+                },
+                new List<Expression>
+                {
+                    Expression.Assign(
+                        serviceVariable,
+                        base.BindToParameter(materializationExpression, entityTypeExpression)),
+                    Expression.Assign(
+                        delegateVariable,
+                        Expression.Condition(
+                            Expression.ReferenceEqual(serviceVariable, Expression.Constant(null)),
+                            Expression.Constant(null, ParameterType),
+                            Expression.Lambda(
+                                Expression.Call(
+                                    serviceVariable,
+                                    Method,
+                                    parameters),
+                                parameters))),
+                    delegateVariable
+                });
+        }
+    }
+}

src/EFCore/Metadata/DependencyInjectionParameterBinding.cs

@@ -0,0 +1,62 @@
+// 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.Linq.Expressions;
+using System.Reflection;
+using JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Internal;
+using Microsoft.EntityFrameworkCore.Storage;
+using Microsoft.EntityFrameworkCore.Utilities;
+
+namespace Microsoft.EntityFrameworkCore.Metadata
+{
+    /// <summary>
+    ///     Describes the binding from an EF internal dependency injection service, which may or may not
+    ///     also have and associated <see cref="IServiceProperty" />, to a parameter in a constructor,
+    ///     factory method, or similar.
+    /// </summary>
+    public class DependencyInjectionParameterBinding : ServiceParameterBinding
+    {
+        private static readonly MethodInfo _getServiceMethod
+            = typeof(InternalAccessorExtensions).GetMethod(nameof(InternalAccessorExtensions.GetService));
+
+        /// <summary>
+        ///     Creates a new <see cref="DependencyInjectionParameterBinding" /> instance for the given service type.
+        /// </summary>
+        /// <param name="parameterType"> The parameter CLR type. </param>
+        /// <param name="serviceType"> The service CLR types, as resolved from dependency injection </param>
+        /// <param name="serviceProperty"> The associated <see cref="IServiceProperty" />, or null. </param>
+        public DependencyInjectionParameterBinding(
+            [NotNull] Type parameterType,
+            [NotNull] Type serviceType,
+            [CanBeNull] IPropertyBase serviceProperty = null)
+            : base(parameterType, serviceType, serviceProperty)
+        {
+        }
+
+        /// <summary>
+        ///     Creates an expression tree representing the binding of the value of a property from a
+        ///     materialization expression to a parameter of the constructor, factory method, etc.
+        /// </summary>
+        /// <param name="materializationExpression"> The expression representing the materialization context. </param>
+        /// <param name="entityTypeExpression"> The expression representing the <see cref="IEntityType" /> constant. </param>
+        /// <returns> The expression tree. </returns>
+        public override Expression BindToParameter(
+            Expression materializationExpression,
+            Expression entityTypeExpression)
+        {
+            Check.NotNull(materializationExpression, nameof(materializationExpression));
+            Check.NotNull(entityTypeExpression, nameof(entityTypeExpression));
+
+            return Expression.Call(
+                _getServiceMethod.MakeGenericMethod(ServiceType),
+                Expression.Convert(
+                    Expression.Property(
+                        materializationExpression,
+                        MaterializationContext.ContextProperty),
+                    typeof(IInfrastructure<IServiceProvider>)));
+        }
+    }
+}