Key Filter Constructor Usage Autofac Issue

Question

I am trying to achieve Resolving instances using Autofac KeyFilter. I am getting results if explicitly resolve the instances using ResolveKeyed<> . However when using KeyFilter in Constructor i am seeing different instances being resolved as parameters.

here is the small example .. i came up..

public enum TestApiEnum
{
    TestA,
    TestB
}
public interface ITestService
{   
}
public interface ITestApi
{
}
public class TestService : ITestService
{
    public TestService([KeyFilter(TestApiEnum.TestA)]ITestApi testApiA, 
    [KeyFilter(TestApiEnum.TestB)] ITestApi testApiB)
    {       
    }
}
public class TestApiA : ITestApi
{
    public TestApiA(TestApiEnum testEnum)
    {
        TestApiEnum = testEnum;
    }
    public TestApiEnum TestApiEnum { get; set; }  
}

public class TestApiB: ITestApi
{
    public TestApiB(TestApiEnum testEnum)
    {
        TestApiEnum = testEnum;
    }
    public TestApiEnum TestApiEnum { get; set; }
}

---

Builder Registration

       builder.RegisterType<TestService>()
            .As<ITestService>();

        builder.RegisterType<TestApiA>()
                .AsImplementedInterfaces()
                .Keyed<ITestApi>(TestApiEnum.TestA)
                .WithAttributeFiltering()
                .WithParameter("testEnum", TestApiEnum.TestA);

        builder.RegisterType<TestApiB>()
               .AsImplementedInterfaces()
               .Keyed<ITestApi>(TestApiEnum.TestB)
               .WithAttributeFiltering()
               .WithParameter("testEnum", TestApiEnum.TestB);

---

var builder = AutofacConfig.ConfigureContainer();
        using (var scope = builder.BeginLifetimeScope())
        {
            // Able to Resolve following two..
            var testApiA = scope.ResolveKeyed<ITestApi>(TestApiEnum.TestA);
            var testApiB = scope.ResolveKeyed<ITestApi>(TestApiEnum.TestB);

            // following test service resolves both parameters as **testApiB** and **testApiB**
            var testservice = scope.Resolve<ITestService>();
        }   

---

Answer 1

i have similar problems with KeyFilter (link)

In your case it is about the following: in constructor KeyFilter don't work - it is an issue :-( it will be resolved only by interface, by last registered interface :-( (in your case TestB)

Check it out.

first case : add:

builder.RegisterType<TestApiB>()                   
               .As<ITestApi>()
               .WithAttributeFiltering()
               .WithParameter("testEnum", TestApiEnum.TestC);

and comment out your registrations (It doesn't matter) --> you (always) get TestC

Second case: swap initial registration --> last registration will be used.

Third case: comment out lines ".AsImplementedInterfaces()": you will get exception until don't register code of first case.

Answer 2

@A_G answer is not completely true: I was able to make constructor injection work in a .NET Core project with Autofac.

The OP's mistake is the same I made at first: WithAttributeFiltering() must be declared at the consumer registration, and not when registering the keyed component.

In other words, this is wrong:

builder.RegisterType<TestService>()
    .As<ITestService>();

builder.RegisterType<TestApiA>()
    .AsImplementedInterfaces()
    .Keyed<ITestApi>(TestApiEnum.TestA)
    .WithAttributeFiltering() // << This won't work.
    .WithParameter("testEnum", TestApiEnum.TestA);

builder.RegisterType<TestApiB>()
    .AsImplementedInterfaces()
    .Keyed<ITestApi>(TestApiEnum.TestB)
    .WithAttributeFiltering() // << Won't also work.
    .WithParameter("testEnum", TestApiEnum.TestB);

But this is right:

builder.RegisterType<TestService>()
    .As<ITestService>()
    .WithAttributeFiltering(); // << Just a single call here.

builder.RegisterType<TestApiA>()
    .AsImplementedInterfaces()
    .Keyed<ITestApi>(TestApiEnum.TestA)
    .WithParameter("testEnum", TestApiEnum.TestA);

builder.RegisterType<TestApiB>()
    .AsImplementedInterfaces()
    .Keyed<ITestApi>(TestApiEnum.TestB)
    .WithParameter("testEnum", TestApiEnum.TestB);

I agree it can be confusing, but Autofac's documentation is also correct (they could maybe make it even more explicit though, it's easy to get it wrong).