Add reflection path for ActivatorUtilities.CreateFactory

src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/ActivatorUtilities.cs

@@ -2,10 +2,12 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq.Expressions;
 using System.Reflection;
+using System.Runtime.CompilerServices;
 using System.Runtime.ExceptionServices;
 using Microsoft.Extensions.Internal;
 
@@ -127,6 +129,13 @@ public static ObjectFactory CreateFactory(
             [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type instanceType,
             Type[] argumentTypes)
         {
+#if NETSTANDARD2_1_OR_GREATER || NET6_0_OR_GREATER
+            if (!RuntimeFeature.IsDynamicCodeSupported)
+            {
+                return CreateFactoryReflection(instanceType, argumentTypes);
+            }
+#endif
+
             CreateFactoryInternal(instanceType, argumentTypes, out ParameterExpression provider, out ParameterExpression argumentArray, out Expression factoryExpressionBody);
 
             var factoryLambda = Expression.Lambda<Func<IServiceProvider, object?[]?, object>>(
@@ -152,6 +161,15 @@ public static ObjectFactory<T>
             CreateFactory<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] T>(
                 Type[] argumentTypes)
         {
+#if NETSTANDARD2_1_OR_GREATER || NET6_0_OR_GREATER
+            if (!RuntimeFeature.IsDynamicCodeSupported)
+            {
+                var factory = CreateFactoryReflection(typeof(T), argumentTypes);
+
+                return (serviceProvider, arguments) => (T)factory(serviceProvider, arguments);
+            }
+#endif
+
             CreateFactoryInternal(typeof(T), argumentTypes, out ParameterExpression provider, out ParameterExpression argumentArray, out Expression factoryExpressionBody);
 
             var factoryLambda = Expression.Lambda<Func<IServiceProvider, object?[]?, T>>(
@@ -264,6 +282,68 @@ private static NewExpression BuildFactoryExpression(
             return Expression.New(constructor, constructorArguments);
         }
 
+#if NETSTANDARD2_1_OR_GREATER || NET6_0_OR_GREATER
+        private static ObjectFactory CreateFactoryReflection(
+            [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type instanceType,
+            Type?[] argumentTypes)
+        {
+            FindApplicableConstructor(instanceType, argumentTypes, out ConstructorInfo constructor, out int?[] parameterMap);
+
+            ParameterInfo[]? constructorParameters = constructor.GetParameters();
+            List<FactoryParameterContext> parameters = new List<FactoryParameterContext>();
+            for (int i = 0; i < constructorParameters.Length; i++)
+            {
+                ParameterInfo constructorParameter = constructorParameters[i];
+                bool hasDefaultValue = ParameterDefaultValue.TryGetDefaultValue(constructorParameter, out object? defaultValue);
+
+                parameters.Add(new FactoryParameterContext(constructorParameter, hasDefaultValue, defaultValue, parameterMap[i]));
+            }
+
+            return (IServiceProvider serviceProvider, object?[]? arguments) =>
+            {
+                var constructorArguments = new object?[parameters.Count];
+                for (int i = 0; i < parameters.Count; i++)
+                {
+                    FactoryParameterContext parameter = parameters[i];
+                    if (parameter.ArgumentIndex is { } index)
+                    {
+                        constructorArguments[i] = arguments?[index];
+                    }
+                    else
+                    {
+                        constructorArguments[i] = GetService(
+                            serviceProvider,
+                            parameter.ParameterInfo.ParameterType,
+                            constructor.DeclaringType!,
+                            parameter.HasDefaultValue);
+                    }
+                    if (parameter.HasDefaultValue && constructorArguments[i] == null)
+                    {
+                        constructorArguments[i] = parameter.DefaultValue;
+                    }
+                }
+
+                return constructor.Invoke(BindingFlags.DoNotWrapExceptions, binder: null, constructorArguments, culture: null);
+            };
+        }
+
+        private sealed class FactoryParameterContext
+        {
+            public FactoryParameterContext(ParameterInfo parameterInfo, bool hasDefaultValue, object? defaultValue, int? argumentIndex)
+            {
+                ParameterInfo = parameterInfo;
+                HasDefaultValue = hasDefaultValue;
+                DefaultValue = defaultValue;
+                ArgumentIndex = argumentIndex;
+            }
+
+            public ParameterInfo ParameterInfo { get; }
+            public bool HasDefaultValue { get; }
+            public object? DefaultValue { get; }
+            public int? ArgumentIndex { get; }
+        }
+#endif
+
         private static void FindApplicableConstructor(
             [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type instanceType,
             Type?[] argumentTypes,

src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.Tests/ActivatorUtilitiesTests.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using Microsoft.DotNet.RemoteExecutor;
 using Xunit;
 using static Microsoft.Extensions.DependencyInjection.Tests.AsyncServiceScopeTests;
 
@@ -171,25 +172,38 @@ public void CreateInstance_ClassWithABC_MultipleCtorsWithSameLength_ThrowsAmbigu
             Assert.Equal(message, exception.Message);
         }
 
-        [Fact]
-        public void CreateFactory_CreatesFactoryMethod()
+        [ConditionalTheory(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
+        [InlineData(true)]
+#if NET6_0_OR_GREATER
+        [InlineData(false)]
+#endif
+        public void CreateFactory_CreatesFactoryMethod(bool isDynamicCodeSupported)
         {
-            var factory1 = ActivatorUtilities.CreateFactory(typeof(ClassWithABCS), new Type[] { typeof(B) });
-            var factory2 = ActivatorUtilities.CreateFactory<ClassWithABCS>(new Type[] { typeof(B) });
-
-            var services = new ServiceCollection();
-            services.AddSingleton(new A());
-            services.AddSingleton(new C());
-            services.AddSingleton(new S());
-            using var provider = services.BuildServiceProvider();
-            object item1 = factory1(provider, new[] { new B() });
-            var item2 = factory2(provider, new[] { new B() });
-
-            Assert.IsType<ObjectFactory>(factory1);
-            Assert.IsType<ClassWithABCS>(item1);
+            var options = new RemoteInvokeOptions();
+            if (!isDynamicCodeSupported)
+            {
+                options.RuntimeConfigurationOptions.Add("System.Runtime.CompilerServices.RuntimeFeature.IsDynamicCodeSupported", isDynamicCodeSupported.ToString());
+            }
 
-            Assert.IsType<ObjectFactory<ClassWithABCS>>(factory2);
-            Assert.IsType<ClassWithABCS>(item2);
+            using var remoteHandle = RemoteExecutor.Invoke(static () =>
+            {
+                var factory1 = ActivatorUtilities.CreateFactory(typeof(ClassWithABCS), new Type[] { typeof(B) });
+                var factory2 = ActivatorUtilities.CreateFactory<ClassWithABCS>(new Type[] { typeof(B) });
+
+                var services = new ServiceCollection();
+                services.AddSingleton(new A());
+                services.AddSingleton(new C());
+                services.AddSingleton(new S());
+                using var provider = services.BuildServiceProvider();
+                object item1 = factory1(provider, new[] { new B() });
+                var item2 = factory2(provider, new[] { new B() });
+
+                Assert.IsType<ObjectFactory>(factory1);
+                Assert.IsType<ClassWithABCS>(item1);
+
+                Assert.IsType<ObjectFactory<ClassWithABCS>>(factory2);
+                Assert.IsType<ClassWithABCS>(item2);
+            }, options);
         }
     }