Type activator should be order agnostic by mapogolions · Pull Request #67493 · dotnet/runtime

mapogolions · 2022-04-02T22:19:38Z

If we have a type with some number of constructors, then the activator always finds the best constructor to activate the instance. This is independent of the order in which these constructors were defined.
Let's look at the following class

 class ValidationResult
{
      public ValidationResult(ValidationStatus status, string description,
           IReadOnlyDictionary<string, object> data)
      {
          Status = status;
          Description = description;
          Data = data;
      }
      
      public ValidationResult(string description, IReadOnlyDictionary<string, object> data)
            : this(ValidationStatus.Valid, description, data) { }

      public ValidationStatus Status { get; }
      public string Description { get; }
      public IReadOnlyDictionary<string, object> Data { get; }
}

var instance = ActivatorUtilities.CreateInstance<ValidationResult>(serviceProvider, "description", data);

The activator will select the second constructor. (i.g. the statement instance.Status is ValidationStatus.Valid will be true)

But if we start using the ActivatorUtilitiesConstructor attribute, then the order in which constructors are defined starts to affect the final result.
Please see unit tests for more details

…constructor is marked

…re it even starts

ghost · 2022-04-02T22:19:44Z

Tagging subscribers to this area: @dotnet/area-extensions-dependencyinjection
See info in area-owners.md if you want to be subscribed.

Issue Details

If we have a type with some number of constructors, then the activator always finds the best constructor to activate the instance. This is independent of the order in which these constructors were defined.
Let's look at the following class

 class ValidationResult
{
      public ValidationResult(ValidationStatus status, string description,
           IReadOnlyDictionary<string, object> data)
      {
          Status = status;
          Description = description;
          Data = data;
      }
      
      public ValidationResult(string description, IReadOnlyDictionary<string, object> data)
            : this(ValidationStatus.Valid, description, data) { }

      public ValidationStatus Status { get; }
      public string Description { get; }
      public IReadOnlyDictionary<string, object> Data { get; }
}

var instance = ActivatorUtilities.CreateInstance<ValidationResult>(serviceProvider, "description", data);

The activator will select the second constructor. (i.g. the statement instance.Status is ValidationStatus.Valid will be true)

But if we start using the ActivatorUtilitiesConstructor attribute, then the order in which constructors are defined starts to affect the final result.
Please see unit tests for more details

Author:	mapogolions
Assignees:	-
Labels:	`area-Extensions-DependencyInjection`
Milestone:	-

am11 · 2022-04-02T23:03:09Z

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

-                    if (isPreferred)
+                if (preferredCtors.Length == 1)
+                {
+                    bestMatcher = new ConstructorMatcher(preferredCtors[0]);


It is wasteful to construct an array, then only use its first element and throw away the rest. This block can be structured like this:

ConstructorInfo? constructorInfo = null; foreach (ConstructorInfo? ctor in ctors) { if (ctor.IsDefined(typeof(ActivatorUtilitiesConstructorAttribute))) { if (constructorInfo is not null) { ThrowMultipleCtorsMarkedWithAttributeException(); } constructorInfo = ctor; } } if (constructorInfo is not null) { ConstructorMatcher bestMatcher = new(constructorInfo); bestLength = bestMatcher.Match(parameters); if (bestLength == -1) { ThrowMarkedCtorDoesNotTakeAllProvidedArguments(); } }

This will also make using System.Linq; unnecessary.

@am11 Thanks for review. Good point

am11 · 2022-04-03T11:43:04Z

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

                    {
-                        bestLength = length;
-                        bestMatcher = matcher;
+                        var matcher = new ConstructorMatcher(constructor);


Suggested change

var matcher = new ConstructorMatcher(constructor);

if (constructor is null)

{

continue;

}

var matcher = new ConstructorMatcher(constructor);

@am11 What do you think if we just replace ConstructorInfo? with the ConstructorInfo in the foreach-loop foreach (~~ConstructorInfo?~~ ConstructorInfo constructor in constructors)? According to documentation the GetConstructors() call should not return collection with nullable elements. https://docs.microsoft.com/en-us/dotnet/api/system.type.getconstructors?view=net-6.0#system-type-getconstructors

Yes, makes sense. Based on the usage elsewhere in the repo, null is not checked. GetConstructor (singular), however, returns nullable object,

eerhardt · 2022-04-03T17:33:53Z

Thanks @mapogolions. Can you also ensure the scenarios listed in #46132 are addressed here as well?

Likewise, while we are fixing this bug, we should ensure the .NET Maui scenario is fixed as well, where the order of constructors looks like this:

    public LoginView(RandomItem item)
    {
        //this is constructor is invoked by code and RandomItem is not registered in DI
        //therefore it should be skipped by ActivatorUtilities.CreateInstance

        InitializeComponent();
    }

    // since there are no other valid constructors, ActivatorUtilities.CreateInstance should pick the default ctor
    public LoginView()
    {
        InitializeComponent();   
    }

mapogolions · 2022-04-03T21:41:54Z

@eerhardt
Initially this PIR fixed this problem #42339
To fix this one #46132 need to a little bit tweak the algorithm for picking up the best constructor. In the last commits, I tried to do it. Please review. I don't know how the idea of fallback constructors will affect performance.

eerhardt

Thanks for getting this fix up @mapogolions. It looks like a great start.

FYI - @davidfowl @halter73 @Tratcher - in case you want to take a look and have any feedback.

eerhardt · 2022-04-27T18:33:52Z

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

+{
+    public class ActivatorUtilitiesTests
+    {
+        [Fact]


Thanks for adding this test. Can you also add one that ensures the default constructor is picked in this scenario?

dotnet/maui#4318 (comment)

Basically:

[Theory] [InlineData(typeof(DefaultConstructorFirst)] [InlineData(typeof(DefaultConstructorLast)] public void ChoosesDefaultConstructorNoMatterOrder(Type instanceType) { var services = new ServiceCollection(); using var provider = services.BuildServiceProvider(); var instance = ActivatorUtilities.CreateInstance(provider, instanceType); Assert.NotNull(instance); } public class DefaultConstructorFirst { public A A { get; } public B B { get; } public DefaultConstructorFirst() {} public DefaultConstructorFirst(ClassA a) { A = a; } public DefaultConstructorFirst(ClassA a, ClassB b) { A = a; B = b; } } public class DefaultConstructorLast { public A A { get; } public B B { get; } public DefaultConstructorLast(ClassA a, ClassB b) { A = a; B = b; } public DefaultConstructorLast(ClassA a) { A = a; } public DefaultConstructorLast() {} }

eerhardt · 2022-04-27T18:40:19Z

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

                _parameterValues = new object?[_parameters.Length];
            }

+            public int ApplyExectLength { get; private set; } = -1;


Suggested change

public int ApplyExectLength { get; private set; } = -1;

public int ApplyExactLength { get; private set; } = -1;

Maybe picking a better name here would help. How about

Suggested change

public int ApplyExectLength { get; private set; } = -1;

public int MatchedLength { get; private set; } = -1;

eerhardt · 2022-04-27T18:51:34Z

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

+            foreach (ConstructorInfo constructor in constructors)
            {
-                foreach (ConstructorInfo? constructor in instanceType.GetConstructors())
+                if (constructor.IsDefined(typeof(ActivatorUtilitiesConstructorAttribute)))


The existing code passes false in for inherit. The new code uses a different overload that passes true for inherit. It's possible that this doesn't really matter for constructors, but I'd prefer to limit the changes to only what is necessary to fix the issue.

Suggested change

if (constructor.IsDefined(typeof(ActivatorUtilitiesConstructorAttribute)))

if (constructor.IsDefined(typeof(ActivatorUtilitiesConstructorAttribute), false))

eerhardt · 2022-04-27T18:57:53Z

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

            }
-
-            return bestMatcher.CreateInstance(provider);
+            var matchers = new ConstructorMatcher[constructors.Length];


I'm thinking about 2 optimizations here:

When there is only a single constructor, just use it.

When there are more than one, is there a way to not allocate an array here? Possibly we could stackalloc up to a reasonable count? Maybe 5 or 10? If the Type has more than that, then allocating an array seems OK since it won't be that common.

Maybe if we do (2), then special-casing (1) becomes unnecessary.

eerhardt · 2022-04-27T19:08:36Z

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

+            {
+                ConstructorInfo constructor = constructors[i];
+                var matcher = new ConstructorMatcher(constructor);
+                _ = matcher.Match(parameters);


Might as well make the Match method return void since no one is consuming the return value anymore.

Tratcher · 2022-04-27T21:11:41Z

Prior related discussion: dotnet/aspnetcore#2871

…ructors are available

mapogolions · 2022-04-29T09:36:14Z

@eerhardt
Thanks for feedback. Could you please review changes. As I understand from the comment above the ActivatorUtilities class should use the longest available constructor now. I've tried to address it. The new requirement breaks the following test case so I fixed it.

…the same priority

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

eerhardt · 2022-04-29T15:22:43Z

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

+
+            var instance = ActivatorUtilities.CreateInstance<Creatable>(provider, a, c);
+
+            Assert.Null(instance.B);


Why should B be null here? There is a scoped service for B, so shouldn't the ctor that takes a B be picked?

As I understand from dotnet/aspnetcore#2915, the longest available constructor should only be used if competing constructors
have the same priority/score (the value of the MatchedLength property reflects it)

Creatable class has two constructors

Ctor(A a, B b, C c, S s)

Ctor(A a, C c, S s) : this(a, null, c, s)

Let's look at the following 3 examples

ActivatorUtilities.CreateInstace(provider, new A(), new C());

According to the algorithm that was invented and used now and which I took as a basis, the first ctor is given score 1, the second one is given score 2 (2 given arguments match sequentially). As result the second constructor will be picked up (b is null)

ActivatorUtilities.CreateInstance(provider, new A())

The first ctor is given score 1, the second ctor is given score 1. We fall into a situation where we have competing constructors. In this case, the rule about the longest available constructor comes into play.

ActivatorUtilities.CreateInstance(provider, new C(), new A()) or ActivatorUtilities.CreateInstance(provider)
Same as above, except for the fact that competing constructors are given score 0.

In the discussion in #46132, it is asking for an ambiguous exception to be thrown to be thrown in this case. Which seems like the right thing IMO. If there are multiple ctors that we can't really pick between, it is better to throw and say "use the ActivatorUtilitiesConstructorAttribute to disambiguate". It is really hard to define perfect behavior here when the "given arguments" and the "services available" can intermix.

See also all the discussion on #46132 for all the scenarios, and the intended behaviors.

@mapogolions - any thoughts on this?

@eerhardt I don't see a way to satisfy all the mentioned requirements (especially ambiguity detection). Feel free to close this as a dead end.

What about using the new (in 6.0) IServiceProviderIsService interface to test if a Type is available as a service in the IServiceProvider?

runtime/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/IServiceProviderIsService.cs

Lines 8 to 19 in b098b6f

/// <summary>

/// Optional service used to determine if the specified type is available from the <see cref="IServiceProvider"/>.

/// </summary>

public interface IServiceProviderIsService

{

/// <summary>

/// Determines if the specified service type is available from the <see cref="IServiceProvider"/>.

/// </summary>

/// <param name="serviceType">An object that specifies the type of service object to test.</param>

/// <returns>true if the specified service is a available, false if it is not.</returns>

bool IsService(Type serviceType);

}

If the IServiceProvider doesn't support this new interface, then using the algorithm proposed here?

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

…I.Tests/ActivatorUtilitiesTests.cs Co-authored-by: Eric Erhardt <eric.erhardt@microsoft.com>

…tions/src/ActivatorUtilities.cs Co-authored-by: Eric Erhardt <eric.erhardt@microsoft.com>

eerhardt · 2022-06-27T14:17:39Z

Closing as per #67493 (comment). Will either re-open or open a new PR to fix this issue.

mapogolions added 5 commits April 3, 2022 02:21

Type activator depends on constructors definition order if preferred …

6d88e34

…constructor is marked

constructor marked as preferred should be considered the first option

4381820

prevent parameter matching in case it is known that it will fail befo…

a859ea8

…re it even starts

break loop if a perfect constructor is found

6f74f65

add empty line

ed5655f

ghost added area-Extensions-DependencyInjection community-contribution Indicates that the PR has been added by a community member labels Apr 2, 2022

am11 reviewed Apr 2, 2022

View reviewed changes

mapogolions added 2 commits April 3, 2022 13:51

replace the wasteful array construction operation

2491f50

rename local variable

5dab06b

am11 reviewed Apr 3, 2022

View reviewed changes

mapogolions added 2 commits April 3, 2022 18:33

fix indent, rename unit test

9cdbf31

remove nullable operator

d9c5458

mapogolions added 4 commits April 4, 2022 02:20

reproduce issue dotnet#46132

d646ee1

fix issue 46132

92f188b

remove prioritized constructor matcher

1012cf0

specify issue

fb7264a

mapogolions added 3 commits April 4, 2022 02:47

refactoring

9beb319

fix sorting

d93c558

add additional checks

a935ddc

eerhardt reviewed Apr 27, 2022

View reviewed changes

mapogolions added 4 commits April 29, 2022 13:36

chooses default constructor no matter order

6d8fdc2

type activator uses longest available constructor when multiple const…

fe1c38e

…ructors are available

refactoring

7e4a363

update method signature

7aabe2c

should use the longest available constructor among constructors with …

9927510

…the same priority

eerhardt reviewed Apr 29, 2022

View reviewed changes

...libraries/Microsoft.Extensions.DependencyInjection/tests/DI.Tests/ActivatorUtilitiesTests.cs Outdated Show resolved Hide resolved

eerhardt reviewed Apr 29, 2022

View reviewed changes

...libraries/Microsoft.Extensions.DependencyInjection/tests/DI.Tests/ActivatorUtilitiesTests.cs Outdated Show resolved Hide resolved

eerhardt reviewed Apr 29, 2022

View reviewed changes

src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/ActivatorUtilities.cs Outdated Show resolved Hide resolved

mapogolions and others added 9 commits April 29, 2022 21:43

Update src/libraries/Microsoft.Extensions.DependencyInjection/tests/D…

68ff999

…I.Tests/ActivatorUtilitiesTests.cs Co-authored-by: Eric Erhardt <eric.erhardt@microsoft.com>

Update src/libraries/Microsoft.Extensions.DependencyInjection/tests/D…

175c637

…I.Tests/ActivatorUtilitiesTests.cs Co-authored-by: Eric Erhardt <eric.erhardt@microsoft.com>

Update src/libraries/Microsoft.Extensions.DependencyInjection.Abstrac…

e03f785

…tions/src/ActivatorUtilities.cs Co-authored-by: Eric Erhardt <eric.erhardt@microsoft.com>

remove dead code

35f0d21

fix typo

d9052f1

Merge branch 'main' into type-activator-should-be-order-agnostic

9ca1980

rename test cases, remove useless code

219e21b

remove assert

686d660

add extra test for the longest available constructor rule

3facdfe

eerhardt closed this Jun 27, 2022

ghost locked as resolved and limited conversation to collaborators Jul 27, 2022

	public int ApplyExectLength { get; private set; } = -1;
	public int ApplyExactLength { get; private set; } = -1;

	public int ApplyExectLength { get; private set; } = -1;
	public int MatchedLength { get; private set; } = -1;

	if (constructor.IsDefined(typeof(ActivatorUtilitiesConstructorAttribute)))
	if (constructor.IsDefined(typeof(ActivatorUtilitiesConstructorAttribute), false))


		var instance = ActivatorUtilities.CreateInstance<Creatable>(provider, a, c);

		Assert.Null(instance.B);

	/// <summary>
	/// Optional service used to determine if the specified type is available from the <see cref="IServiceProvider"/>.
	/// </summary>
	public interface IServiceProviderIsService
	{
	/// <summary>
	/// Determines if the specified service type is available from the <see cref="IServiceProvider"/>.
	/// </summary>
	/// <param name="serviceType">An object that specifies the type of service object to test.</param>
	/// <returns>true if the specified service is a available, false if it is not.</returns>
	bool IsService(Type serviceType);
	}

Conversation

mapogolions commented Apr 2, 2022

Uh oh!

ghost commented Apr 2, 2022

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

mapogolions Apr 3, 2022 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

eerhardt commented Apr 3, 2022

Uh oh!

mapogolions commented Apr 3, 2022 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

eerhardt left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Tratcher commented Apr 27, 2022

Uh oh!

mapogolions commented Apr 29, 2022 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

mapogolions Apr 29, 2022 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

eerhardt Jun 1, 2022 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

eerhardt commented Jun 27, 2022

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

4 participants

mapogolions Apr 3, 2022 •

edited

Loading

mapogolions commented Apr 3, 2022 •

edited

Loading

mapogolions commented Apr 29, 2022 •

edited

Loading

mapogolions Apr 29, 2022 •

edited

Loading

eerhardt Jun 1, 2022 •

edited

Loading