autofac：多次注册具有不同依赖项的同一个类

Question

Given the following heirarchy:
I need to resolve one instance of ProducerRepository per registered IParser dependency when an IEnumerable<ISourceRepository<IDatum>> is resolved.

public class ProducerRepository : ISourceRepository<Data>
{
    public ProducerRepository(IRepository repository)
    {}
}

public interface ISourceRepository<out T> where T : class, IDatum
{}

public class Repository : IRepository
{
    public Repository(IParser parser)
    {}
}

public class ParserTypeOne : IParser {}
public class ParserTypeTwo : IParser {}

I need to register ProducerRepository as follows.

builder.RegisterType<ProducerRepository>()           
.WithParserTypeOne() // how do I specify this as a particular dependency
.As<ISourceRepository<IDatum>();

builder.RegisterType<ProducerRepository>()          
.WithParserTypeTwo() // another type of parser.
.As<ISourceRepository<IDatum>>();

// OR: better still if at all possible...
builder.RegisterType<ProducerRepository>() // one of these for each underlying dependency
.WithEachPossibleTypeOfParser() // one for each dependency
.As<ISourceRepository<IDatum>>();

I need to know how to register the class twice, once with each type of dependency, so that when an IEnumerable<ISourceRepository<IDatum>> is resolved I get a separate instance of ProducerRepository for each different implementation of the parser.

Better still, it would be nice to be able to register a separate ProducerRepository for each instance of the parser found in the assembly scan, and add it.

I was hoping not to have to resort to changing the implementation to use Keyed or Meta registrations as that locks in each dependency and changes the implementation. If that is the only way of doing it, I will accept the answer. I am hoping for a generic way to register all the possible implementations .

Answer 1

If we reduce the problem, you want that :

public class Pouet
{
    public Pouet(Foo foo) { }
}
public class Foo
{
    public Foo(IBar bar) { }
}
public interface IBar { }
public class Bar1 : IBar { }
public class Bar2 : IBar { }

and

    ContainerBuilder builder = new ContainerBuilder();
    builder.RegisterType<Pouet>().AsSelf();
    builder.RegisterType<Foo>().AsSelf();
    builder.RegisterType<Bar1>().As<IBar>();
    builder.RegisterType<Bar2>().As<IBar>();
    IContainer container = builder.Build();

    IEnumerable<Pouet> pouets = container.Resolve<IEnumerable<Pouet>>();

    Console.WriteLine(pouets.Count()); // => must return 2 here !

Basically, to return more than 1 Pouet using container.Resolve<IEnumerable<Pouet>>() container must have more than 1 registration of Pouet same thing for Foo . In order to do that, you can make this ugly thing :

    // don't do that
    ContainerBuilder builder = new ContainerBuilder();
    builder.RegisterType<Pouet>().Named<Pouet>("initial");
    builder.RegisterType<Foo>().Named<Foo>("initial");
    builder.Register(c => c.ResolveNamed<Pouet>("initial", TypedParameter.From<Foo>(c.Resolve<IEnumerable<Meta<Foo>>>().Where(m => (Int32)m.Metadata["Bar"] == 1).Select(m => m.Value).First()))).As<Pouet>().WithMetadata("Bar", 1);
    builder.Register(c => c.ResolveNamed<Pouet>("initial", TypedParameter.From<Foo>(c.Resolve<IEnumerable<Meta<Foo>>>().Where(m => (Int32)m.Metadata["Bar"] == 1).Select(m => m.Value).First()))).As<Pouet>().WithMetadata("Bar", 2);
    builder.Register(c => c.ResolveNamed<Foo>("initial",TypedParameter.From<IBar>(c.Resolve<IEnumerable<Meta<IBar>>>().Where(m => (Int32)m.Metadata["Bar"] == 1).Select(m => m.Value).First()))).As<Foo>().WithMetadata("Bar", 1);
    builder.Register(c => c.ResolveNamed<Foo>("initial",TypedParameter.From<IBar>(c.Resolve<IEnumerable<Meta<IBar>>>().Where(m => (Int32)m.Metadata["Bar"] == 2).Select(m => m.Value).First()))).As<Foo>().WithMetadata("Bar", 2);
    builder.RegisterType<Bar1>().As<IBar>().WithMetadata("Bar", 1);
    builder.RegisterType<Bar2>().As<IBar>().WithMetadata("Bar", 2);

    IContainer container = builder.Build();

    IEnumerable<Pouet> pouets = container.Resolve<IEnumerable<Pouet>>();

    Console.WriteLine(pouets.Count()); // => 2 !

If you add a new intermediate dependency or a new IBar , you will have to write a lot of code. Using a custom IRegistrationSource , it should be possible to automate these uglies registrations but it will be quite complex and not really efficient.

Another solution would be to play with lifetimeScope :

    ContainerBuilder builder = new ContainerBuilder();
    builder.RegisterType<Pouet>().AsSelf();
    builder.RegisterType<Foo>().AsSelf();
    builder.RegisterType<Bar1>().As<IBar>();
    builder.RegisterType<Bar2>().As<IBar>();

    IContainer container = builder.Build();

    using (ILifetimeScope workScope = container.BeginLifetimeScope())
    {
        List<Pouet> pouets = new List<Pouet>();

        foreach (IComponentRegistration registration in container.ComponentRegistry.RegistrationsFor(new TypedService(typeof(IBar))))
        {
            using (ILifetimeScope scope = container.BeginLifetimeScope(cb => cb.RegisterComponent(registration)))
            {
                Pouet pouet = scope.Resolve<Pouet>();
                workScope.Disposer.AddInstanceForDisposal(scope);
                pouets.Add(pouet);
            }
        }

        Console.WriteLine(pouets.Count);
    }

By the way this code could be used inside an IRegistrationSource so you should be able to resolve IEnumerable<Pouet>() on your container.

If possible, I would recommend to refactor your code and make it simpler, playing with instance coming from another ILifetimeScope could be problematic and I'm not really confident about disposal of these instances : what happens if a type is registered as InstancePerLifetimeScope (I have not tried) ? etc.