The priority logic for selecting parameters in the decorator pattern is incorrect

[zms9110750]

Describe the Bug

The priority logic for selecting types in the decorator pattern is incorrect.

Steps to Reproduce

var builder = new ContainerBuilder();
builder.RegisterType<A>().As<IA>();
builder.RegisterType<Ab>().As<IAb>();
builder.RegisterDecorator<D, IA>();
/*builder.RegisterDecorator<IA>(
  (context, parameters, instance) =>
  {
	  Console.WriteLine(instance.GetType());
	  Console.WriteLine(context.Resolve<IAb>().GetType());

	  return new D(context.Resolve<IAb>(), instance);
  });*/

var container = builder.Build();

var d = container.Resolve<IA>();

interface IA;
interface IAb : IA;
class A : IA;
class Ab : IAb;
record D(IAb ab, IA a) : IA;

Expected Behavior

Use the correct registered types to inject into D and let D replace IA.

Exception with Stack Trace

Unhandled exception. Autofac.Core.DependencyResolutionException: An exception was thrown while activating D.
 ---> Autofac.Core.DependencyResolutionException: An exception was thrown while invoking the constructor 'Void .ctor(IAb, IA)' on type 'D'.
 ---> System.InvalidCastException: Unable to cast object of type 'A' to type 'IAb'.
   at lambda_method3(Closure, Object[])
   at Autofac.Core.Activators.Reflection.BoundConstructor.Instantiate()
   --- End of inner exception stack trace ---

Dependency Versions

Autofac: Autofac: 8.2.1

Additional Info

• The issue arises when Autofac attempts to resolve IA using RegisterDecorator. The decorator D expects an IAb parameter, but Autofac incorrectly attempts to provide an instance of A (which only implements IA), leading to an InvalidCastException.
• The Ab class is explicitly registered as IAb, so it should be recognized as a valid implementation for both IA and IAb.

[tillig]

Interesting. There's definitely something going on here. I am able to reproduce it with the provided code.

A note on the expectations - if you register Ab only as IAb, it will only be allowed to be used as an IAb even though it can technically be cast down. If you want Ab to be both IA and IAb, you'd need to do

// Either this...
builder.RegisterType<Ab>().AsImplementedInterfaces();

// OR this...
builder.RegisterType<Ab>().As<IA>().As<IAb>();

Autofac is very specific about the type mapping.

But - the issue you're mentioning here is still totally an issue. The container should be able to figure out what you're trying to do and get it done.

Messing around with it, it seems like there's a challenge in the parameter selection where It's trying hard to map parameter type to interface to something that can supply that value, and there's a mismatch. If, for example, I change it so Ab does not implement IAb and then just pass Ab around as itself, things work:

 var builder = new ContainerBuilder();
builder.RegisterType<A>().As<IA>();
builder.RegisterType<Ab>().AsSelf();
builder.RegisterDecorator<D, IA>();
var container = builder.Build();
var d = container.Resolve<IA>();
Assert.NotNull(d);

public interface IA;
public class A : IA;
public class Ab;
public record D(IA a, Ab ab) : IA;

It's as soon as that IAb interface shows up, that's when there's a problem. Even if you only register Ab AsSelf(), you still get the same error.

I recall back in #1330 we had some challenges with getting resolved/compatible parameters to work in a decorator situation so we added a fix here. If I had to guess, there's some conflict between the solution for that issue and the desired results for this one.

I can't say I'm going to be able to jump right on this, so if a solution to this is interesting to you, I'd recommend/encourage submitting a PR with a fix and tests to ensure we don't regress the issue.