Type activator should be order agnostic

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

@@ -2,6 +2,7 @@
 // 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;
@@ -31,49 +32,58 @@ public static object CreateInstance(
             [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type instanceType,
             params object[] parameters)
         {
-            int bestLength = -1;
-            bool seenPreferred = false;
+            string? message = $"A suitable constructor for type '{instanceType}' could not be located. Ensure the type is concrete and all parameters of a public constructor are either registered as services or passed as arguments. Also ensure no extraneous arguments are provided.";
+            if (instanceType.IsAbstract)
+            {
+                throw new InvalidOperationException(message);
+            }
 
-            ConstructorMatcher bestMatcher = default;
+            ConstructorInfo[] constructors = instanceType.GetConstructors();
+            if (constructors.Length == 0)
+            {
+                throw new InvalidOperationException(message);
+            }
 
-            if (!instanceType.IsAbstract)
+            ConstructorInfo? pereferredConstructor = null;
+            foreach (ConstructorInfo constructor in constructors)
             {
-                foreach (ConstructorInfo? constructor in instanceType.GetConstructors())
+                if (constructor.IsDefined(typeof(ActivatorUtilitiesConstructorAttribute)))
                 {
-                    var matcher = new ConstructorMatcher(constructor);
-                    bool isPreferred = constructor.IsDefined(typeof(ActivatorUtilitiesConstructorAttribute), false);
-                    int length = matcher.Match(parameters);
-
-                    if (isPreferred)
+                    if (pereferredConstructor is not null)
                     {
-                        if (seenPreferred)
-                        {
-                            ThrowMultipleCtorsMarkedWithAttributeException();
-                        }
-
-                        if (length == -1)
-                        {
-                            ThrowMarkedCtorDoesNotTakeAllProvidedArguments();
-                        }
-                    }
-
-                    if (isPreferred || bestLength < length)
-                    {
-                        bestLength = length;
-                        bestMatcher = matcher;
+                        ThrowMultipleCtorsMarkedWithAttributeException();
                     }
-
-                    seenPreferred |= isPreferred;
+                    pereferredConstructor = constructor;
                 }
             }
-
-            if (bestLength == -1)
+            if (pereferredConstructor is not null)
             {
-                string? message = $"A suitable constructor for type '{instanceType}' could not be located. Ensure the type is concrete and all parameters of a public constructor are either registered as services or passed as arguments. Also ensure no extraneous arguments are provided.";
-                throw new InvalidOperationException(message);
+                var matcher = new ConstructorMatcher(pereferredConstructor);
+                if (matcher.Match(parameters) == -1)
+                {
+                    ThrowMarkedCtorDoesNotTakeAllProvidedArguments();
+                }
+                return matcher.CreateInstance(provider, throwIfFailed: true)!;
             }
-
-            return bestMatcher.CreateInstance(provider);
+            var matchers = new ConstructorMatcher[constructors.Length];
+            for (int i = 0; i < constructors.Length; i++)
+            {
+                ConstructorInfo constructor = constructors[i];
+                var matcher = new ConstructorMatcher(constructor);
+                _ = matcher.Match(parameters);
+                matchers[i] = matcher;
+            }
+            Array.Sort(matchers, (a, b) => b.ApplyExectLength - a.ApplyExectLength);
+            object? instance = null;
+            for (int i = 0; i < matchers.Length; i++)
+            {
+                ConstructorMatcher matcher = matchers[i];
+                if (matcher.ApplyExectLength == -1) break;
+                bool lastChance = i == matchers.Length - 1;
+                instance = matcher.CreateInstance(provider, throwIfFailed: lastChance);
+                if (instance is not null) return instance;
+            }
+            throw new InvalidOperationException(message);
         }
 
         /// <summary>
@@ -336,10 +346,16 @@ public ConstructorMatcher(ConstructorInfo constructor)
                 _parameterValues = new object?[_parameters.Length];
             }
 
+            public int ApplyExectLength { get; private set; } = -1;
+
             public int Match(object[] givenParameters)
             {
+                if (givenParameters.Length > _parameters.Length)
+                {
+                    return ApplyExectLength;
+                }
                 int applyIndexStart = 0;
-                int applyExactLength = 0;
+                ApplyExectLength = 0;
                 for (int givenIndex = 0; givenIndex != givenParameters.Length; givenIndex++)
                 {
                     Type? givenType = givenParameters[givenIndex]?.GetType();
@@ -357,21 +373,22 @@ public int Match(object[] givenParameters)
                                 applyIndexStart++;
                                 if (applyIndex == givenIndex)
                                 {
-                                    applyExactLength = applyIndex;
+                                    ApplyExectLength = applyIndex;
                                 }
                             }
                         }
                     }
 
                     if (givenMatched == false)
                     {
-                        return -1;
+                        ApplyExectLength = -1;
+                        return ApplyExectLength;
                     }
                 }
-                return applyExactLength;
+                return ApplyExectLength;
             }
 
-            public object CreateInstance(IServiceProvider provider)
+            public object? CreateInstance(IServiceProvider provider, bool throwIfFailed = false)
             {
                 for (int index = 0; index != _parameters.Length; index++)
                 {
@@ -382,7 +399,11 @@ public object CreateInstance(IServiceProvider provider)
                         {
                             if (!ParameterDefaultValue.TryGetDefaultValue(_parameters[index], out object? defaultValue))
                             {
-                                throw new InvalidOperationException($"Unable to resolve service for type '{_parameters[index].ParameterType}' while attempting to activate '{_constructor.DeclaringType}'.");
+                                if (throwIfFailed)
+                                {
+                                    throw new InvalidOperationException($"Unable to resolve service for type '{_parameters[index].ParameterType}' while attempting to activate '{_constructor.DeclaringType}'.");
+                                }
+                                return null;
                             }
                             else
                             {

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

@@ -0,0 +1,142 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections.Generic;
+using Xunit;
+
+namespace Microsoft.Extensions.DependencyInjection.Tests
+{
+    public class ActivatorUtilitiesTests
+    {
+        [Fact]
+        public void ShouldFixIssue_46132()
+        {
+            var services = new ServiceCollection();
+            services.AddScoped<S>();
+            using var provider = services.BuildServiceProvider();
+            var a = new A();
+            var c = new C();
+
+            var instance = ActivatorUtilities.CreateInstance<Creatable>(
+                provider, c, a);
+
+            Assert.NotNull(instance);
+            Assert.Same(a, instance.A);
+            Assert.Same(c, instance.C);
+            Assert.NotNull(instance.S);
+            Assert.Null(instance.B);
+        }
+
+        [Theory]
+        [MemberData(nameof(ActivatorUtilitiesData))]
+        public void ShouldFixIssue_42339(Type instanceType)
+        {
+            var data = new Dictionary<string, object>();
+            var serviceProvider = new FakeServiceProvider(t =>
+            {
+                if (t == typeof(FakeValidationStatus)) return FakeValidationStatus.Invalid;
+                throw new NotImplementedException();
+            });
+
+            var instance = (IFakeValidationResult)ActivatorUtilities
+                .CreateInstance(serviceProvider, instanceType, "description", data);
+
+            Assert.Equal(FakeValidationStatus.Invalid, instance.Status);
+        }
+
+        public static TheoryData<Type> ActivatorUtilitiesData
+        {
+            get => new TheoryData<Type>
+            {
+                typeof(FakeValidationResult),
+                typeof(FakeValidationResultOps)
+            };
+        }
+    }
+
+    internal class A { }
+    internal class B { }
+    internal class C { }
+    internal class S { }
+
+    internal class Creatable
+    {
+        public A A { get; }
+        public B? B { get; }
+        public C C { get; }
+        public S S { get; }
+        public Creatable(A a, B b, C c, S s)
+        {
+            A = a;
+            B = b;
+            C = c;
+            S = s;
+        }
+
+        public Creatable(A a, C c, S s) : this (a, null, c, s) { }
+    }
+
+    internal class FakeServiceProvider : IServiceProvider
+    {
+        private readonly Func<Type, object?> _factory;
+
+        public FakeServiceProvider(Func<Type, object?> factory)
+        {
+            _factory = factory;
+        }
+
+        public object? GetService(Type serviceType) => _factory(serviceType);
+    }
+
+    internal interface IFakeValidationResult
+    {
+        FakeValidationStatus Status { get; }
+        string Description { get; }
+        IReadOnlyDictionary<string, object> Data { get; }
+    }
+
+    internal class FakeValidationResult : IFakeValidationResult
+    {
+        [ActivatorUtilitiesConstructor]
+        public FakeValidationResult(FakeValidationStatus status, string description,
+           IReadOnlyDictionary<string, object> data)
+        {
+            Status = status;
+            Description = description;
+            Data = data;
+        }
+
+        public FakeValidationResult(string description, IReadOnlyDictionary<string, object> data)
+            : this(FakeValidationStatus.Valid, description, data) { }
+
+        public FakeValidationStatus Status { get; }
+        public string Description { get; }
+        public IReadOnlyDictionary<string, object> Data { get; }
+    }
+
+    internal class FakeValidationResultOps : IFakeValidationResult
+    {
+        public FakeValidationResultOps(string description, IReadOnlyDictionary<string, object> data)
+            : this(FakeValidationStatus.Valid, description, data) { }
+
+        [ActivatorUtilitiesConstructor]
+        public FakeValidationResultOps(FakeValidationStatus status, string description,
+           IReadOnlyDictionary<string, object> data)
+        {
+            Status = status;
+            Description = description;
+            Data = data;
+        }
+
+        public FakeValidationStatus Status { get; }
+        public string Description { get; }
+        public IReadOnlyDictionary<string, object> Data { get; }
+    }
+
+    internal enum FakeValidationStatus
+    {
+        Valid,
+        Invalid
+    }
+}