Question

I have an application which might needs to connect to multiple databases. But each module will only connect to one db. So I though it might make sense to isolate the db into each module so each module will get its own db auto resolved and I don’t need to bother with named registration. But to my astonishment, it seems that Autofac’s module is more a code module than a logical module (am I wrong here?): IA

[Test]
public void test_module_can_act_as_scope_container()
{
    ContainerBuilder builder = new ContainerBuilder();
    builder.RegisterModule(new Module1());

    IContainer c = builder.Build();
    var o = c.ResolveNamed<CB>("One");
    Assert.That(o.A.Name, Is.EqualTo("One"));

    builder = new ContainerBuilder();
    builder.RegisterModule(new Module1());
    builder.RegisterModule(new Module2());
    c = builder.Build();
    var t = c.ResolveNamed<CB>("One");
    Assert.That(t.A.Name, Is.EqualTo("Two"));
}

And the interfaces/Modules used:

public interface IA
{
    string Name { get; set; }
}

public class CA : IA
{
    public string Name { get; set; }
}

public class CB
{
    public CB(IA a)
    {
        A = a;
    }
    public IA A { get; private set; }
}

public class Module1 : Module
{
    protected override void Load(ContainerBuilder builder)
    {
        builder.Register(c => new CA() { Name = "One" }).As<IA>();
        builder.RegisterType<CB>().Named("One", typeof(CB));
    }
}

public class Module2 : Module
{
    protected override void Load(ContainerBuilder builder)
    {
        builder.Register(c => new CA() { Name = "Two" }).As<IA>();
        builder.RegisterType<CB>().Named("Two", typeof(CB));
    }
}

Answer 1

Yes, you’re kind of correct.

Modules serve only for splitting configuration into somewhat independent parts. They do not scope configuration in any way. Having modules is actually the same as if you merged all modules’ Load methods’ code into a single configuration method and then built the container.

In your case your Module2 actually overrides the registration for IA interface from Module1.

I’ve also been interested in finding a solution to the problem. I’ve come to the following approach:

Keyed service

var key = new object();
builder.Register(c => new CA() { Name = "Two" }).Keyed<IA>(key);
builder.RegisterType<CB>().Named("Two", typeof(CB))
  .WithParameter(new ResolvedParameter(
      (pi, ctx) => pi.Type == typeof(IA),
      (pi, ctx) => ctx.ResolveKeyed<IA>(key)
  ));

Pros:

You can control which IA instances will be injected in each module.

Contras:

1. It’s quite a lot of code
2. It does not make IA component ‘internal’ to the module – other modules can still resolve it using simple Resolve<IA>. Modules aren’t isolated.

Hope this helps

UPDATE

In some cases it may be easier, and frankly more correct from design point of view, to make it this way:

Delegate registration

builder.Register(ctx => new CB(new CA { Name = "Two" }))
  .Named("Two", typeof(CB));

Pros:

1. You don’t expose your module-specific CA to other modules

Contras:

1. If CA and CB have complex dependencies and a lot of constructor parameters, you’ll end up with mess of constructing code
2. If you need to use CA in several places inside a module, you’ll have to find a way to avoid copy-pasting

Nested Container instances

And yet another option is having an independent Container inside each module. This way all modules will be able to have their private container configurations. However, AFAIK, Autofac doesn’t provide any built-in means to somehow link several Container instances. Although I suppose implementing this should not be very difficult.